8 | {{ PostCtrl.post.title }} 9 | {{ PostCtrl.post.created_at | date }} 10 |
11 |{{ PostCtrl.post.content }}
12 |
7 |
22 |
`,
23 | controller: 'EditCtrl',
24 | controllerAs: 'EditCtrl',
25 | resolve: {
26 | post: ['$route', function ($route) {
27 | const id = $route.current.params.id
28 | if (id && id !== 'new') {
29 | return store.find('post', id)
30 | }
31 | }]
32 | }
33 | })
34 | }]
35 |
36 | export const Edit = ['$route', '$routeParams', '$location', '$timeout', function ($route, $routeParams, $location, $timeout) {
37 | this.post = $route.current.locals.post || store.createRecord('post')
38 |
39 | this.onSubmit = function () {
40 | const id = $routeParams.id
41 | const props = {
42 | title: this.post.title,
43 | content: this.post.content
44 | }
45 | let promise
46 | if (id === 'new') {
47 | promise = store.create('post', props)
48 | } else {
49 | promise = store.update('post', id, props)
50 | }
51 | promise.then((post) => {
52 | $timeout(() => {
53 | $location.path(`/posts/${post.id}`)
54 | })
55 | }, console.error)
56 | }
57 | }]
58 |
--------------------------------------------------------------------------------
/client/angular1/src/header.js:
--------------------------------------------------------------------------------
1 | import angular from 'angular'
2 |
3 | const config = {
4 | restrict: 'E',
5 | replace: true,
6 | template: ``,
44 | controllerAs: 'HeaderCtrl',
45 | controller () {
46 | this.login = function ($event) {
47 | $event.preventDefault()
48 | window.location = '/auth/github'
49 | }
50 | }
51 | }
52 |
53 | export const Header = function () {
54 | return config
55 | }
56 |
--------------------------------------------------------------------------------
/client/angular1/src/index.js:
--------------------------------------------------------------------------------
1 | document.getElementsByTagName('html')[0].setAttribute('data-ng-app', 'app')
2 |
3 | const container = document.createElement('div')
4 | container.className = 'container'
5 |
6 | const mainContainer = document.createElement('div')
7 | mainContainer.setAttribute('data-ng-view', '')
8 | mainContainer.className = 'container main-container'
9 |
10 | container.appendChild(document.createElement('main-header'))
11 | container.appendChild(mainContainer)
12 |
13 | document.getElementById('app').appendChild(container)
14 |
15 | import './app'
16 |
--------------------------------------------------------------------------------
/client/angular1/src/post.js:
--------------------------------------------------------------------------------
1 | import angular from 'angular'
2 | import {store} from './store'
3 |
4 | export const PostConfig = ['$routeProvider', function ($routeProvider) {
5 | $routeProvider.when('/posts/:id', {
6 | template: `
7 |
`,
13 | controller: 'PostCtrl',
14 | controllerAs: 'PostCtrl',
15 | resolve: {
16 | post: ['$route', function ($route) {
17 | return store.find('post', $route.current.params.id)
18 | }]
19 | }
20 | })
21 | }]
22 |
23 | export const Post = ['$scope', '$timeout', '$route', '$routeParams', function ($scope, $timeout, $route, $routeParams) {
24 | this.post = $route.current.locals.post
25 |
26 | this.onChange = function () {
27 | $timeout(() => {
28 | this.post = store.get('post', $routeParams.id)
29 | })
30 | }
31 |
32 | store.on('all', this.onChange, this)
33 |
34 | $scope.$on('$destroy', () => {
35 | store.off('all', this.onChange)
36 | })
37 | }]
38 |
--------------------------------------------------------------------------------
/client/angular1/src/posts.js:
--------------------------------------------------------------------------------
1 | import angular from 'angular'
2 | import {store} from './store'
3 |
4 | const PAGE_SIZE = 5
5 |
6 | /**
7 | * @param {number} pageNum The page to retrieve.
8 | * @return {Promise} A Promise that resolves to a Page object.
9 | */
10 | function fetchPage (pageNum) {
11 | return store.getMapper('post').findAll({
12 | limit: PAGE_SIZE,
13 | offset: (pageNum - 1) * PAGE_SIZE,
14 | orderBy: [['created_at', 'desc']]
15 | }).then(function (page) {
16 | page.data = store.add('post', page.data)
17 | return page
18 | })
19 | }
20 |
21 | export const PostsConfig = ['$routeProvider', function ($routeProvider) {
22 | $routeProvider.when('/', {
23 | template: `
24 |
30 |
31 | 25 | {{ post.title }} 26 | {{ post.created_at | date }} 27 |
28 |{{ post.content | limitTo:200 }}...
29 | 30 |
32 | No posts yet...
33 |
34 | `,
63 | controller: 'PostsCtrl',
64 | controllerAs: 'PostsCtrl',
65 | resolve: {
66 | page: function () {
67 | return fetchPage(1)
68 | }
69 | }
70 | })
71 | }]
72 |
73 | export const Posts = ['$timeout', '$route', function ($timeout, $route) {
74 | this.PAGE_SIZE = PAGE_SIZE
75 | this.currentPage = $route.current.locals.page.page
76 | this.total = $route.current.locals.page.total
77 | this.posts = $route.current.locals.page.data
78 |
79 | this.fetchPage = function (pageNum) {
80 | fetchPage(pageNum).then((page) => {
81 | this.currentPage = page.page
82 | this.total = page.total
83 | $timeout(() => {
84 | this.posts = store.filter('post', {
85 | limit: this.PAGE_SIZE,
86 | offset: (this.currentPage - 1) * this.PAGE_SIZE,
87 | orderBy: [['created_at', 'DESC']]
88 | })
89 | })
90 | })
91 | }
92 |
93 | this.prev = function (pageDecrease) {
94 | if (this.currentPage > 1) {
95 | this.fetchPage(this.currentPage - pageDecrease)
96 | }
97 | }
98 |
99 | this.next = function (pageIncrease) {
100 | if ((this.currentPage * this.PAGE_SIZE) < this.total) {
101 | this.fetchPage(this.currentPage + pageIncrease)
102 | }
103 | }
104 | }]
105 |
--------------------------------------------------------------------------------
/client/angular1/src/store.js:
--------------------------------------------------------------------------------
1 | // DataStore is mostly recommended for use in the browser
2 | import {
3 | DataStore,
4 | Schema,
5 | utils
6 | } from 'js-data'
7 | import HttpAdapter from 'js-data-http'
8 | const schemas = require('../../../_shared/schemas')(Schema)
9 | import * as relations from '../../../_shared/relations'
10 |
11 | const convertToDate = function (record) {
12 | if (typeof record.created_at === 'string') {
13 | record.created_at = new Date(record.created_at)
14 | }
15 | if (typeof record.updated_at === 'string') {
16 | record.updated_at = new Date(record.updated_at)
17 | }
18 | }
19 |
20 | export const adapter = new HttpAdapter({
21 | // Our API sits behind the /api path
22 | basePath: '/api'
23 | })
24 | export const store = new DataStore({
25 | mapperDefaults: {
26 | // Override the original to make sure the date properties are actually Date
27 | // objects
28 | createRecord (props, opts) {
29 | const result = this.constructor.prototype.createRecord.call(this, props, opts)
30 | if (Array.isArray(result)) {
31 | result.forEach(convertToDate)
32 | } else if (this.is(result)) {
33 | convertToDate(result)
34 | }
35 | return result
36 | }
37 | }
38 | })
39 |
40 | store.registerAdapter('http', adapter, { default: true })
41 |
42 | // The User Resource
43 | store.defineMapper('user', {
44 | // Our API endpoints use plural form in the path
45 | endpoint: 'users',
46 | schema: schemas.user,
47 | relations: relations.user,
48 | getLoggedInUser () {
49 | if (this.loggedInUser) {
50 | return utils.resolve(this.loggedInUser)
51 | }
52 | return store.getAdapter('http').GET('/api/users/loggedInUser')
53 | .then((response) => {
54 | const user = this.loggedInUser = response.data
55 | if (user) {
56 | this.loggedInUser = store.add('user', user)
57 | }
58 | return this.loggedInUser
59 | })
60 | }
61 | })
62 |
63 | // The Post Resource
64 | store.defineMapper('post', {
65 | // Our API endpoints use plural form in the path
66 | endpoint: 'posts',
67 | schema: schemas.post,
68 | relations: relations.post,
69 | // "GET /posts" doesn't return data as JSData expects, so we override the
70 | // default "wrap" method and add some extra logic to make sure that the
71 | // correct data gets turned into Record instances
72 | wrap (data, opts) {
73 | if (opts.op === 'afterFindAll') {
74 | data.data = this.createRecord(data.data)
75 | return data
76 | } else {
77 | return this.createRecord(data)
78 | }
79 | }
80 | })
81 |
82 | // The Comment Resource
83 | store.defineMapper('comment', {
84 | // Our API endpoints use plural form in the path
85 | endpoint: 'comments',
86 | schema: schemas.comment,
87 | relations: relations.comment
88 | })
89 |
--------------------------------------------------------------------------------
/client/angular1/webpack.config.js:
--------------------------------------------------------------------------------
1 | var webpack = require('webpack')
2 |
3 | module.exports = {
4 | devtool: 'source-map',
5 | entry: './src/index.js',
6 | output: {
7 | path: '../public',
8 | publicPath: '/public/',
9 | filename: 'bundle.js'
10 | },
11 | module: {
12 | loaders: [
13 | {
14 | test: /\.js$/,
15 | exclude: /node_modules/,
16 | loader: 'babel-loader'
17 | }
18 | ]
19 | }
20 | }
21 |
--------------------------------------------------------------------------------
/client/angular2/.gitignore:
--------------------------------------------------------------------------------
1 | typings
2 | node_modules
--------------------------------------------------------------------------------
/client/angular2/package.json:
--------------------------------------------------------------------------------
1 | {
2 | "name": "js-data-examples-angular2",
3 | "description": "Angular 2.x client for js-data-examples",
4 | "version": "3.0.0-alpha.1",
5 | "homepage": "https://github.com/js-data/js-data-examples",
6 | "repository": {
7 | "type": "git",
8 | "url": "https://github.com/js-data/js-data-examples.git"
9 | },
10 | "author": "js-data-examples project authors",
11 | "license": "MIT",
12 | "private": true,
13 | "scripts": {
14 | "bundle": "webpack --config webpack.config.js",
15 | "watch": "webpack --config webpack.config.js --watch",
16 | "typings": "typings",
17 | "postinstall": "typings install"
18 | },
19 | "devDependencies": {
20 | "ts-loader": "^0.8.2",
21 | "typescript": "^1.8.10",
22 | "typings": "^0.7.11",
23 | "webpack": "^1.13.1"
24 | },
25 | "dependencies": {
26 | "@angular/common": "2.0.0-rc.1",
27 | "@angular/compiler": "2.0.0-rc.1",
28 | "@angular/core": "2.0.0-rc.1",
29 | "@angular/http": "2.0.0-rc.1",
30 | "@angular/platform-browser": "2.0.0-rc.1",
31 | "@angular/platform-browser-dynamic": "2.0.0-rc.1",
32 | "@angular/router": "2.0.0-rc.1",
33 | "@angular/router-deprecated": "2.0.0-rc.1",
34 | "@angular/upgrade": "2.0.0-rc.1",
35 | "es6-promise": "^3.1.2",
36 | "es6-shim": "^0.35.0",
37 | "js-data": "^3.0.0-beta.5",
38 | "js-data-http": "^3.0.0-beta.5",
39 | "reflect-metadata": "^0.1.3",
40 | "rxjs": "^5.0.0-beta.6",
41 | "zone.js": "^0.6.12"
42 | }
43 | }
44 |
--------------------------------------------------------------------------------
/client/angular2/src/app.ts:
--------------------------------------------------------------------------------
1 | import {Component} from '@angular/core'
2 | import {ROUTER_DIRECTIVES, RouteConfig} from '@angular/router-deprecated'
3 | import {HeaderComponent} from './header'
4 | import {PostsComponent} from './posts'
5 | import {PostComponent} from './post'
6 | import {EditComponent} from './edit'
7 | import {store, IUser, IUserMapper} from './store'
8 |
9 | const UserMapper =
15 |
20 | `,
21 | directives: [ROUTER_DIRECTIVES, HeaderComponent]
22 | })
23 | @RouteConfig([
24 | { path: '/', component: PostsComponent, name: 'Posts' },
25 | { path: '/posts/:id', component: PostComponent, name: 'Post' },
26 | { path: '/posts/:id/edit', component: EditComponent, name: 'Edit' }
27 | ])
28 | export class AppComponent {
29 | loggedInUser: IUser
30 |
31 | constructor () {
32 | // Fetch the current user, if any
33 | UserMapper.getLoggedInUser().then((user) => {
34 | this.loggedInUser = user
35 | })
36 | }
37 | }
38 |
--------------------------------------------------------------------------------
/client/angular2/src/edit.ts:
--------------------------------------------------------------------------------
1 | import {Component,Input} from '@angular/core'
2 | import {Router, RouteParams} from '@angular/router-deprecated'
3 | import {store, IPost} from './store'
4 |
5 | @Component({
6 | selector: 'edit',
7 | template: `
8 |
17 |
19 |
9 |
24 |
25 | `
26 | })
27 | export class EditComponent {
28 | post: IPost =
9 |
15 | `,
16 | directives: [ROUTER_DIRECTIVES]
17 | })
18 | export class PostComponent {
19 | post: IPost
20 |
21 | constructor (private _routeParams: RouteParams) {
22 | store.find('post', _routeParams.get('id')).then((post) => {
23 | this.post = post
24 | store.on('all', this.onChange, this)
25 | })
26 | }
27 | ngOnDestroy () { store.off('all', this.onChange) }
28 | onChange () { this.post = store.get('post', this._routeParams.get('id')) }
29 | }
30 |
--------------------------------------------------------------------------------
/client/angular2/src/posts.ts:
--------------------------------------------------------------------------------
1 | import {Component,Input} from '@angular/core'
2 | import {ROUTER_DIRECTIVES} from '@angular/router-deprecated'
3 | import {store, IPost} from './store'
4 |
5 | const PAGE_SIZE: number = 5
6 |
7 | interface IPage {
8 | total: number
9 | page: number
10 | data: IPost[]
11 | }
12 |
13 | /**
14 | * @param {number} pageNum The page to retrieve.
15 | * @return {Promise} A Promise that resolves to an IPage instance.
16 | */
17 | function fetchPage (pageNum: number): Promise10 | {{ post?.title }} 11 | {{ post?.created_at | date }} 12 |
13 |{{ post?.content }}
14 |
35 |
`,
71 | directives: [ROUTER_DIRECTIVES]
72 | })
73 | export class PostsComponent {
74 | posts: IPost[] = []
75 | currentPage: number = 1
76 | total: number = 0
77 | PAGE_SIZE: number = PAGE_SIZE
78 |
79 | constructor () {
80 | this.fetchPage(this.currentPage)
81 | }
82 | fetchPage (pageNum: number): void {
83 | fetchPage(pageNum).then((page) => {
84 | this.currentPage = page.page
85 | this.total = page.total
86 | this.posts = store.filter('post', {
87 | limit: this.PAGE_SIZE,
88 | offset: (this.currentPage - 1) * this.PAGE_SIZE,
89 | orderBy: [['created_at', 'DESC']]
90 | })
91 | })
92 | }
93 | prev ($event: Event, pageDecrease: number): void {
94 | $event.preventDefault()
95 | if (this.currentPage > 1) {
96 | this.fetchPage(this.currentPage - pageDecrease)
97 | }
98 | }
99 | next ($event: Event, pageIncrease: number): void {
100 | $event.preventDefault()
101 | if ((this.currentPage * this.PAGE_SIZE) < this.total) {
102 | this.fetchPage(this.currentPage + pageIncrease)
103 | }
104 | }
105 | }
106 |
--------------------------------------------------------------------------------
/client/angular2/src/store.ts:
--------------------------------------------------------------------------------
1 | // DataStore is mostly recommended for use in the browser
2 | import {
3 | DataStore,
4 | Mapper,
5 | Record,
6 | Schema,
7 | utils
8 | } from 'js-data'
9 | import {HttpAdapter} from 'js-data-http'
10 |
11 | declare var require: any
12 |
13 | const schemas = require('../../../_shared/schemas')(Schema)
14 | const relations = require('../../../_shared/relations')
15 |
16 | const convertToDate = function (record) {
17 | if (typeof record.created_at === 'string') {
18 | record.created_at = new Date(record.created_at)
19 | }
20 | if (typeof record.updated_at === 'string') {
21 | record.updated_at = new Date(record.updated_at)
22 | }
23 | }
24 |
25 | export const adapter = new HttpAdapter({
26 | // Our API sits behind the /api path
27 | basePath: '/api'
28 | })
29 | export const store = new DataStore({
30 | mapperDefaults: {
31 | // Override the original to make sure the date properties are actually Date
32 | // objects
33 | createRecord (props, opts) {
34 | const result = this.constructor.prototype.createRecord.call(this, props, opts)
35 | if (Array.isArray(result)) {
36 | result.forEach(convertToDate)
37 | } else if (this.is(result)) {
38 | convertToDate(result)
39 | }
40 | return result
41 | }
42 | }
43 | })
44 |
45 | store.registerAdapter('http', adapter, { default: true })
46 |
47 | export interface IUser extends Record {
48 | id: string|number
49 | displayName: string
50 | username: string
51 | created_at: string|Date
52 | updated_at: string|Date
53 | }
54 |
55 | export interface IUserMapper extends Mapper {
56 | loggedInUser: IUser
57 | getLoggedInUser(): Promise
36 |
42 | 37 | {{ post.title }} 38 | {{ post.created_at | date }} 39 |
40 |{{ post.content }}
41 | No posts yet...
43 |
70 |
15 |
20 | `,
21 | directives: [ROUTER_DIRECTIVES, HeaderComponent]
22 | })
23 | @RouteConfig([
24 | { path: '/', component: PostsComponent, name: 'Posts' },
25 | { path: '/posts/:id', component: PostComponent, name: 'Post' },
26 | { path: '/posts/:id/edit', component: EditComponent, name: 'Edit' }
27 | ])
28 | export class AppComponent {
29 | loggedInUser: IUser
30 |
31 | constructor () {
32 | // Fetch the current user, if any
33 | UserMapper.getLoggedInUser().then((user) => {
34 | this.loggedInUser = user
35 | })
36 | }
37 | }
38 |
--------------------------------------------------------------------------------
/client/angular2_firebase/src/edit.ts:
--------------------------------------------------------------------------------
1 | import {Component, Input} from '@angular/core'
2 | import {Router, RouteParams} from '@angular/router-deprecated'
3 | import {store, IUserMapper, IUser, IPost} from './store'
4 | const UserMapper =
17 |
19 |
10 |
25 |
26 | `
27 | })
28 |
29 | export class EditComponent {
30 | post: IPost =
9 |
15 | `,
16 | directives: [ROUTER_DIRECTIVES]
17 | })
18 | export class PostComponent {
19 | post: IPost
20 |
21 | constructor (private _routeParams: RouteParams) {
22 | store.find('post', _routeParams.get('id')).then((post) => {
23 | this.post = post
24 | store.on('all', this.onChange, this)
25 | })
26 | }
27 | ngOnDestroy () { store.off('all', this.onChange) }
28 | onChange () { this.post = store.get('post', this._routeParams.get('id')) }
29 | }
30 |
--------------------------------------------------------------------------------
/client/angular2_firebase/src/posts.ts:
--------------------------------------------------------------------------------
1 | import {Component,Input} from '@angular/core'
2 | import {ROUTER_DIRECTIVES} from '@angular/router-deprecated'
3 | import {store, IPost} from './store'
4 |
5 | const PAGE_SIZE: number = 5
6 |
7 | interface IPage {
8 | total: number
9 | page: number
10 | data: IPost[]
11 | }
12 |
13 | /**
14 | * @param {number} pageNum The page to retrieve.
15 | * @return {Promise} A Promise that resolves to an IPage instance.
16 | */
17 | function fetchPage (pageNum: number): Promise10 | {{ post?.title }} 11 | {{ post?.created_at | date }} 12 |
13 |{{ post?.content }}
14 |
41 |
`,
77 | directives: [ROUTER_DIRECTIVES]
78 | })
79 | export class PostsComponent {
80 | posts: IPost[] = []
81 | currentPage: number = 1
82 | total: number = 0
83 | PAGE_SIZE: number = PAGE_SIZE
84 |
85 | constructor () {
86 | this.fetchPage(this.currentPage)
87 | }
88 | fetchPage (pageNum: number): void {
89 | fetchPage(pageNum).then((page) => {
90 | this.currentPage = page.page
91 | this.total = page.total
92 | this.posts = store.filter('post', {
93 | limit: this.PAGE_SIZE,
94 | offset: (this.currentPage - 1) * this.PAGE_SIZE,
95 | orderBy: [['created_at', 'DESC']]
96 | })
97 | })
98 | }
99 | prev ($event: Event, pageDecrease: number): void {
100 | $event.preventDefault()
101 | if (this.currentPage > 1) {
102 | this.fetchPage(this.currentPage - pageDecrease)
103 | }
104 | }
105 | next ($event: Event, pageIncrease: number): void {
106 | $event.preventDefault()
107 | if ((this.currentPage * this.PAGE_SIZE) < this.total) {
108 | this.fetchPage(this.currentPage + pageIncrease)
109 | }
110 | }
111 | }
112 |
--------------------------------------------------------------------------------
/client/angular2_firebase/src/store.ts:
--------------------------------------------------------------------------------
1 | // DataStore is mostly recommended for use in the browser
2 | import {
3 | DataStore,
4 | Mapper,
5 | Record,
6 | Schema,
7 | utils
8 | } from 'js-data'
9 | import {FirebaseAdapter, IBaseFirebaseAdapter} from 'js-data-firebase'
10 |
11 | declare var require: any
12 |
13 | const schemas = require('../../../_shared/schemas')(Schema)
14 | const relations = require('../../../_shared/relations')
15 |
16 | const convertToDate = function (record) {
17 | if (typeof record.created_at === 'string') {
18 | record.created_at = new Date(record.created_at)
19 | }
20 | if (typeof record.updated_at === 'string') {
21 | record.updated_at = new Date(record.updated_at)
22 | }
23 | }
24 |
25 | const config = {
26 | apiKey: "AIzaSyBm19OK4uJG7opzSRcS91jp1zTP7FYk258",
27 | authDomain: "js-data-firebase-v3.firebaseapp.com",
28 | databaseURL: "https://js-data-firebase-v3.firebaseio.com/",
29 | storageBucket: "",
30 | };
31 | firebase.initializeApp(config);
32 | export const firebaseAdapter: IBaseFirebaseAdapter = new FirebaseAdapter({
33 | // Our API sits behind the /api path
34 | db: firebase.database()
35 | })
36 | export const store = new DataStore({
37 | mapperDefaults: {
38 | // Override the original to make sure the date properties are actually Date
39 | // objects
40 | beforeCreate(props, opts) {
41 | props.created_at = new Date().toISOString()
42 | props.updated_at = new Date().toISOString()
43 | return props
44 | },
45 | beforeUpdate(props, opts) {
46 | props.updated_at = new Date().toISOString()
47 | return props
48 | },
49 | createRecord(props, opts) {
50 | const result = this.constructor.prototype.createRecord.call(this, props, opts)
51 | if (Array.isArray(result)) {
52 | result.forEach(convertToDate)
53 | } else if (this.is(result)) {
54 | convertToDate(result)
55 | }
56 | return result
57 | }
58 | }
59 | })
60 |
61 | store.registerAdapter('firebase', firebaseAdapter, { default: true })
62 |
63 | export interface IUser extends Record {
64 | id: string | number
65 | displayName: string
66 | username: string
67 | created_at: string | Date
68 | updated_at: string | Date
69 | }
70 |
71 | export interface IUserMapper extends Mapper {
72 | loggedInUser: IUser
73 | getLoggedInUser(): Promise
42 |
48 | 43 | {{ post.title }} 44 | {{ post.created_at | date }} 45 |
46 |{{ post.content }}
47 | No posts yet...
49 |
76 |
25 |
26 |
28 | )
29 | }
30 | }
31 |
--------------------------------------------------------------------------------
/client/react/src/edit.js:
--------------------------------------------------------------------------------
1 | import React from 'react'
2 | import {store} from './store'
3 |
4 | export default class Edit extends React.Component {
5 | constructor (props) {
6 | super(props)
7 | const id = this.props.params.id
8 | if (id && id !== 'new') {
9 | store.find('post', id).then((post) => {
10 | this.setState({
11 | title: post.title,
12 | content: post.content
13 | })
14 | })
15 | }
16 | this.state = { title: '', content: '' }
17 | }
18 | onTitleChange (e) {
19 | e.preventDefault()
20 | this.setState({ title: e.target.value })
21 | }
22 | onContentChange (e) {
23 | e.preventDefault()
24 | this.setState({ content: e.target.value })
25 | }
26 | onSubmit (e) {
27 | const id = this.props.params.id
28 | e.preventDefault()
29 | const props = {
30 | title: this.state.title,
31 | content: this.state.content
32 | }
33 | let promise
34 | if (id === 'new') {
35 | promise = store.create('post', props)
36 | } else {
37 | promise = store.update('post', id, props)
38 | }
39 | promise.then((post) => {
40 | this.context.router.push(`/posts/${post.id}`)
41 | })
42 | }
43 | render () {
44 | return (
45 | {this.props.children}
27 |
46 |
61 |
62 | )
63 | }
64 | }
65 |
66 | Edit.contextTypes = { router: React.PropTypes.object }
67 |
--------------------------------------------------------------------------------
/client/react/src/header.js:
--------------------------------------------------------------------------------
1 | import React from 'react'
2 | import { Router, Route, hashHistory, IndexRoute, Link } from 'react-router'
3 | import {store} from './store'
4 |
5 | export default React.createClass({
6 | render () {
7 | const loggedInUser = this.props.loggedInUser
8 | const path = window.location.pathname
9 | const links = [
10 |
32 |
54 | )
55 | }
56 | })
57 |
--------------------------------------------------------------------------------
/client/react/src/index.js:
--------------------------------------------------------------------------------
1 | import React from 'react'
2 | import {render} from 'react-dom'
3 | import {Router, Route, browserHistory, IndexRoute} from 'react-router'
4 | import App from './app'
5 | import Posts from './posts'
6 | import Post from './post'
7 | import Edit from './edit'
8 |
9 | render((
10 |
33 |
53 |
34 | js-data blog example
35 |
40 |
41 |
52 |
21 |
27 | )
28 | }
29 | }
30 |
31 | Post.contextTypes = { router: React.PropTypes.object }
32 |
--------------------------------------------------------------------------------
/client/react/src/posts.js:
--------------------------------------------------------------------------------
1 | import React from 'react'
2 | import {Link} from 'react-router'
3 | import {store} from './store'
4 |
5 | const PAGE_SIZE = 5
6 |
7 | /**
8 | * @param {number} pageNum The page to retrieve.
9 | * @return {Promise} A Promise that resolves to a Page object.
10 | */
11 | function fetchPage (pageNum) {
12 | return store.getMapper('post').findAll({
13 | limit: PAGE_SIZE,
14 | offset: (pageNum - 1) * PAGE_SIZE,
15 | orderBy: [['created_at', 'desc']]
16 | }).then(function (page) {
17 | page.data = store.add('post', page.data)
18 | return page
19 | })
20 | }
21 |
22 | export default class Posts extends React.Component {
23 | constructor (props) {
24 | super(props)
25 | fetchPage(1).then((page) => {
26 | this.setState(this.getState(1, page))
27 | })
28 | this.state = { posts: [], currentPage: 1, total: 0 }
29 | }
30 | getState (currentPage, page) {
31 | return {
32 | currentPage: page.page,
33 | total: page.total,
34 | posts: store.filter('post', {
35 | limit: PAGE_SIZE,
36 | offset: (currentPage - 1) * PAGE_SIZE,
37 | orderBy: [['created_at', 'DESC']]
38 | })
39 | }
40 | }
41 | fetchPage (pageNum) {
42 | fetchPage(pageNum).then((page) => {
43 | this.setState(this.getState(pageNum, page))
44 | })
45 | }
46 | prev (e, pageDecrease) {
47 | e.preventDefault()
48 | if (this.state.currentPage > 1) {
49 | this.fetchPage(this.state.currentPage - pageDecrease)
50 | }
51 | }
52 | next (e, pageIncrease) {
53 | e.preventDefault()
54 | if ((this.state.currentPage * PAGE_SIZE) < this.state.total) {
55 | this.fetchPage(this.state.currentPage + pageIncrease)
56 | }
57 | }
58 | render () {
59 | const currentPage = this.state.currentPage
60 | const total = this.state.total
61 | let posts = this.state.posts.map(function (post) {
62 | return (
63 | 22 | {this.state.post.title} 23 | {this.state.post.created_at} 24 |
25 |{this.state.post.content}
26 |
64 |
70 | )
71 | })
72 | const links = [
73 | 65 | {post.title} 66 | {post.created_at} 67 |
68 |{post.content.substring(0, 200)}...
69 |
113 |
)
116 | }
117 | }
118 |
--------------------------------------------------------------------------------
/client/react/src/store.js:
--------------------------------------------------------------------------------
1 | // DataStore is mostly recommended for use in the browser
2 | import {
3 | DataStore,
4 | Schema,
5 | utils
6 | } from 'js-data'
7 | import HttpAdapter from 'js-data-http'
8 | import * as schemas from '../../../_shared/schemas'
9 | import * as relations from '../../../_shared/relations'
10 |
11 | const convertToDate = function (record) {
12 | if (typeof record.created_at === 'string') {
13 | record.created_at = new Date(record.created_at)
14 | }
15 | if (typeof record.updated_at === 'string') {
16 | record.updated_at = new Date(record.updated_at)
17 | }
18 | }
19 |
20 | export const adapter = new HttpAdapter({
21 | // Our API sits behind the /api path
22 | basePath: '/api'
23 | })
24 | export const store = new DataStore({
25 | mapperDefaults: {
26 | // Override the original to make sure the date properties are actually Date
27 | // objects
28 | createRecord (props, opts) {
29 | const result = this.constructor.prototype.createRecord.call(this, props, opts)
30 | if (Array.isArray(result)) {
31 | result.forEach(convertToDate)
32 | } else if (this.is(result)) {
33 | convertToDate(result)
34 | }
35 | return result
36 | }
37 | }
38 | })
39 |
40 | store.registerAdapter('http', adapter, { default: true })
41 |
42 | // The User Resource
43 | store.defineMapper('user', {
44 | // Our API endpoints use plural form in the path
45 | endpoint: 'users',
46 | schema: schemas.user,
47 | relations: relations.user,
48 | getLoggedInUser () {
49 | if (this.loggedInUser) {
50 | return utils.resolve(this.loggedInUser)
51 | }
52 | return store.getAdapter('http').GET('/api/users/loggedInUser')
53 | .then((response) => {
54 | const user = this.loggedInUser = response.data
55 | if (user) {
56 | this.loggedInUser = store.add('user', user)
57 | }
58 | return this.loggedInUser
59 | })
60 | }
61 | })
62 |
63 | // The Post Resource
64 | store.defineMapper('post', {
65 | // Our API endpoints use plural form in the path
66 | endpoint: 'posts',
67 | schema: schemas.post,
68 | relations: relations.post,
69 | // "GET /posts" doesn't return data as JSData expects, so we override the
70 | // default "wrap" method and add some extra logic to make sure that the
71 | // correct data gets turned into Record instances
72 | wrap (data, opts) {
73 | if (opts.op === 'afterFindAll') {
74 | data.data = this.createRecord(data.data)
75 | return data
76 | } else {
77 | return this.createRecord(data)
78 | }
79 | }
80 | })
81 |
82 | // The Comment Resource
83 | store.defineMapper('comment', {
84 | // Our API endpoints use plural form in the path
85 | endpoint: 'comments',
86 | schema: schemas.comment,
87 | relations: relations.comment
88 | })
89 |
--------------------------------------------------------------------------------
/client/react/src/user.js:
--------------------------------------------------------------------------------
1 | var UserView = React.createClass({
2 | contextTypes: {
3 | router: React.PropTypes.func
4 | },
5 | /*
6 | * Lifecycle
7 | */
8 | getInitialState() {
9 | var params = this.context.router.getCurrentParams();
10 | User.find(params.id, {bypassCache: true});
11 | return this.getState(params);
12 | },
13 | componentDidMount: function () {
14 | User.on('DS.change', this.onChange);
15 | Post.on('DS.change', this.onChange);
16 | Comment.on('DS.change', this.onChange);
17 | },
18 | componentWillUnmount: function () {
19 | User.off('DS.change', this.onChange);
20 | Post.off('DS.change', this.onChange);
21 | Comment.off('DS.change', this.onChange);
22 | },
23 | /*
24 | * Event Handlers
25 | */
26 | onChange: function () {
27 | this.setState(this.getState(this.context.router.getCurrentParams()));
28 | },
29 | /*
30 | * Methods
31 | */
32 | getState: function (params) {
33 | return {
34 | user: User.get(params.id) || {}
35 | };
36 | },
37 | render: function () {
38 | return (
39 | {posts}
114 | {nav}
115 |
40 |
76 | );
77 | }
78 | });
79 |
--------------------------------------------------------------------------------
/client/react/webpack.config.js:
--------------------------------------------------------------------------------
1 | var webpack = require('webpack')
2 |
3 | module.exports = {
4 | devtool: 'source-map',
5 | entry: './src/index.js',
6 | output: {
7 | path: '../public',
8 | publicPath: '/public/',
9 | filename: 'bundle.js'
10 | },
11 | module: {
12 | loaders: [
13 | {
14 | test: /\.js$/,
15 | exclude: /node_modules/,
16 | loader: 'babel-loader'
17 | }
18 | ]
19 | }
20 | }
21 |
--------------------------------------------------------------------------------
/server/.gitignore:
--------------------------------------------------------------------------------
1 | node_modules
2 | rethinkdb_data
3 | *.log
4 | config.json
--------------------------------------------------------------------------------
/server/config.default.json:
--------------------------------------------------------------------------------
1 | {
2 | "ADAPTER": "rethinkdb",
3 | "CLIENT": "react",
4 | "DB_HOST": "localhost",
5 | "DB_PORT": null,
6 | "DB": "blog",
7 | "GITHUB_CLIENT_ID": "",
8 | "GITHUB_CLIENT_SECRET": "",
9 | "GITHUB_CALLBACK_URL": ""
10 | }
--------------------------------------------------------------------------------
/server/package.json:
--------------------------------------------------------------------------------
1 | {
2 | "name": "js-data-examples-server",
3 | "description": "Backend for js-data-examples",
4 | "version": "3.0.0-alpha.1",
5 | "homepage": "https://github.com/js-data/js-data-examples",
6 | "repository": {
7 | "type": "git",
8 | "url": "https://github.com/js-data/js-data-examples.git"
9 | },
10 | "author": "js-data-examples project authors",
11 | "license": "MIT",
12 | "private": true,
13 | "scripts": {
14 | "start": "node src/index.js"
15 | },
16 | "dependencies": {
17 | "bluebird": "^3.3.4",
18 | "body-parser": "^1.13.2",
19 | "cookie-parser": "^1.4.1",
20 | "express": "^4.13.4",
21 | "express-session": "^1.13.0",
22 | "js-data": "^3.0.0-beta.6",
23 | "js-data-mongodb": "^1.0.0-beta.1",
24 | "js-data-rethinkdb": "^3.0.0-beta.6",
25 | "js-data-sql": "^1.0.0-beta.3",
26 | "nconf": "^0.8.4",
27 | "passport": "^0.3.2",
28 | "passport-github": "^1.1.0",
29 | "source-map-support": "^0.4.0"
30 | }
31 | }
32 |
--------------------------------------------------------------------------------
/server/rethinkdb/.gitignore:
--------------------------------------------------------------------------------
1 | node_modules
2 | rethinkdb_data
3 | *.log
4 | config.js
--------------------------------------------------------------------------------
/server/rethinkdb/README.md:
--------------------------------------------------------------------------------
1 | 41 | {this.state.user.name } 42 |
43 | 44 |
45 |
75 |
46 |
59 | Posts
47 | 48 | {this.state.user.posts.map(function (post) { 49 | return ( 50 |
51 | {post.title}
52 |
53 | {moment(post.created_at).fromNow()}
54 |
55 |
56 | );
57 | })}
58 |
60 |
74 | Comments
61 | 62 | {this.state.user.comments.map(function (comment) { 63 | return ( 64 |
65 | Go to post
66 | {comment.body}
67 |
68 | {moment(comment.created_at).fromNow()}
69 |
70 |
71 | );
72 | })}
73 | 
2 |
3 | ## server-side js-data w/RethinkDB
4 |
5 | #### Quick Start
6 | This will default to using the js-data + Angular frontend client
7 |
8 | 1. `cd js-data-examples/server/rethinkdb`
9 | 1. `rethinkdb` (Start rethinkdb, if you don't already have an instance running somewhere else
10 | 1. `node app/app.js` (In another terminal)
11 | 1. `open localhost:3000` (In another terminal)
12 |
13 | Modify `app/local.config.js` as necessary.
14 |
--------------------------------------------------------------------------------
/server/rethinkdb/app/app.js:
--------------------------------------------------------------------------------
1 | var express = require('express');
2 | var http = require('http');
3 | var bodyParser = require('body-parser');
4 | var cookieParser = require('cookie-parser');
5 | var session = require('express-session');
6 | var methodOverride = require('method-override');
7 | var GitHubStrategy = require('passport-github').Strategy;
8 | var path = require('path');
9 | var container = require('./container');
10 |
11 | // This allows us to programmatically start the app in a test environment
12 | exports.createServer = function () {
13 |
14 | // Bootstrap the application, injecting a bunch of dependencies
15 | return container.resolve(function (User, safeCall, users, posts, comments, errorHandler, queryRewrite, rewriteRelations, passport, config) {
16 | var app = express();
17 |
18 | // Simple route middleware to ensure user is authenticated.
19 | // Use this route middleware on any resource that needs to be protected. If
20 | // the request is authenticated (typically via a persistent login session),
21 | // the request will proceed. Otherwise, the user will be redirected to the
22 | // login page.
23 | function ensureAuthenticated(req, res, next) {
24 | if (req.isAuthenticated()) {
25 | return next();
26 | }
27 | res.redirect('/login');
28 | }
29 |
30 | function renderIndex(req, res, next) {
31 | res.render('index.html', {}, function (err, html) {
32 | if (err) {
33 | next(err);
34 | } else {
35 | res.send(html);
36 | }
37 | });
38 | }
39 |
40 | // Passport session setup.
41 | // To support persistent login sessions, Passport needs to be able to
42 | // serialize users into and deserialize users out of the session. Typically,
43 | // this will be as simple as storing the user ID when serializing, and finding
44 | // the user by ID when deserializing. However, since this example does not
45 | // have a database of user records, the complete GitHub profile is serialized
46 | // and deserialized.
47 | passport.serializeUser(function (user, done) {
48 | done(null, user);
49 | });
50 |
51 | passport.deserializeUser(function (obj, done) {
52 | done(null, obj);
53 | });
54 |
55 | // Use the GitHubStrategy within Passport.
56 | // Strategies in Passport require a `verify` function, which accept
57 | // credentials (in this case, an accessToken, refreshToken, and GitHub
58 | // profile), and invoke a callback with a user object.
59 | passport.use(new GitHubStrategy({
60 | clientID: config.GITHUB_CLIENT_ID,
61 | clientSecret: config.GITHUB_CLIENT_SECRET,
62 | callbackURL: config.GITHUB_CALLBACK_URL
63 | },
64 | function (accessToken, refreshToken, profile, done) {
65 | User.findAll({
66 | github_id: profile.id
67 | }).then(function (users) {
68 | if (users.length) {
69 | return users[0];
70 | } else {
71 | return User.create({
72 | username: profile.username,
73 | avatar_url: profile._json.avatar_url,
74 | github_id: profile.id,
75 | name: profile.displayName,
76 | created_at: new Date()
77 | });
78 | }
79 | }).then(function (user) {
80 | return done(null, user);
81 | }).catch(function (err) {
82 | done(err);
83 | });
84 | }
85 | ));
86 |
87 | // middleware
88 | app.use(queryRewrite);
89 | app.use(rewriteRelations);
90 | app.use(bodyParser.json());
91 | app.use(cookieParser());
92 | app.use(bodyParser.urlencoded({ extended: true }));
93 | app.use(methodOverride());
94 |
95 | // I'm only using Express to render/serve the index.html file and other static assets for simplicity with the example apps
96 | app.set('views', path.resolve(config.PUBLIC_PATH));
97 | app.set('view engine', 'ejs');
98 | app.engine('html', require('ejs').renderFile);
99 |
100 | // Using Express/Passports for simplicity in the example. I would never use this in production.
101 | app.use(session({ secret: 'keyboard cat' }));
102 | app.use(passport.initialize());
103 | app.use(passport.session());
104 | // PUBLIC_PATH is used to choose with frontend client to use. Default is the js-data + Angular client.
105 | app.use(express.static(path.resolve(config.PUBLIC_PATH)));
106 |
107 | // app settings
108 | app.enable('trust proxy');
109 |
110 | app.get('/', renderIndex);
111 |
112 | /******************************/
113 | /********** comments **********/
114 | /******************************/
115 | app.route('/api/comments')
116 | // GET /comments
117 | .get(safeCall(comments.findAll))
118 | // POST /comments
119 | .post(ensureAuthenticated, safeCall(comments.createOne));
120 |
121 | app.route('/api/comments/:id')
122 | .put(ensureAuthenticated, safeCall(comments.updateOneById))
123 | .delete(ensureAuthenticated, safeCall(comments.deleteOneById));
124 |
125 | /*******************************/
126 | /********** posts **********/
127 | /*******************************/
128 | app.route('/api/posts')
129 | .get(safeCall(posts.findAll))
130 | .post(ensureAuthenticated, safeCall(posts.createOne));
131 |
132 | app.route('/api/posts/:id')
133 | .get(safeCall(posts.findOneById))
134 | .put(ensureAuthenticated, safeCall(posts.updateOneById))
135 | .delete(ensureAuthenticated, safeCall(posts.deleteOneById));
136 |
137 | /*******************************/
138 | /********** users **************/
139 | /*******************************/
140 | app.get('/api/users/loggedInUser', function (req, res) {
141 | if (req.isAuthenticated()) {
142 | return res.json(req.user);
143 | } else {
144 | res.send();
145 | }
146 | });
147 |
148 | app.route('/api/users')
149 | .get(safeCall(users.findAll));
150 |
151 | app.route('/api/users/:id')
152 | .get(safeCall(users.findOneById));
153 |
154 | // Normally I would have a bunch of user-related routes, but I'm
155 | // just using Passport.js + Github for simplicity in the example
156 |
157 | /*******************************/
158 | /*********** auth **************/
159 | /*******************************/
160 | app.get('/auth/github', passport.authenticate('github'));
161 | app.get('/auth/github/callback', passport.authenticate('github', { failureRedirect: '/login' }), function (req, res) {
162 | res.redirect('/');
163 | });
164 | app.post('/api/logout', function (req, res) {
165 | req.logout();
166 | res.redirect('/');
167 | });
168 | app.post('/api/socket.io/', function (req, res, next) {
169 | next();
170 | });
171 |
172 | // Redirect all others to the index (HTML5 history)
173 | app.get('*', function (req, res, next) {
174 | if (req.originalUrl.indexOf('socket.io') === -1) {
175 | renderIndex(req, res, next);
176 | }
177 | });
178 |
179 | // Catch-all error handler
180 | app.use(function (err, req, res, next) {
181 | errorHandler(err, req, res, next);
182 | });
183 |
184 | return app;
185 | });
186 | };
187 |
188 | // This allows us to programmatically start the app in a test environment
189 | if (module === require.main || process.env.NODE_ENV === 'prod') {
190 | var app = exports.createServer();
191 | var server = http.createServer(app);
192 | var config = container.get('config');
193 | server.listen(config.PORT);
194 | }
195 |
--------------------------------------------------------------------------------
/server/rethinkdb/app/container.js:
--------------------------------------------------------------------------------
1 | // dependable is and IOC container library
2 | // we register components with the container, and modules declare dependencies that they need injected
3 | var dependable = require('dependable');
4 | var path = require('path');
5 |
6 | var container = dependable.container();
7 |
8 | // Load and register app config
9 | container.register('config', function () {
10 | return {
11 | PORT: process.env.PORT || 3000,
12 |
13 | // database configuration
14 | DB_HOST: process.env.DB_HOST || '127.0.0.1',
15 | DB_PORT: process.env.DB_PORT || 28015,
16 | DB_DATABASE: process.env.DB_DATABASE || 'jsdata',
17 |
18 | // Login won't work without these
19 | GITHUB_CLIENT_ID: process.env.GITHUB_CLIENT_ID || '',
20 | GITHUB_CLIENT_SECRET: process.env.GITHUB_CLIENT_SECRET || '',
21 |
22 | GITHUB_CALLBACK_URL: process.env.GITHUB_CALLBACK_URL || 'http://127.0.0.1:3000/auth/github/callback',
23 |
24 | // Default to using the js-data + angular example for the client.
25 | PUBLIC_PATH: process.env.PUBLIC_PATH || '../../../client/angular'
26 | };
27 | });
28 |
29 | // 3rd-party dependencies
30 | // Anything registered with the container becomes trivial to mock in tests
31 | container.register('mout', function () {
32 | return require('mout');
33 | });
34 | container.register('Promise', function () {
35 | return require('bluebird');
36 | });
37 | container.register('passport', function () {
38 | return require('passport');
39 | });
40 |
41 | // Create and register a js-data-rethinkdb adapter with the container
42 | container.register('rethinkdbAdapter', function (config) {
43 | var DSRethinkDbAdapter = require('js-data-rethinkdb');
44 | return new DSRethinkDbAdapter({
45 | host: config.DB_HOST,
46 | port: config.DB_PORT,
47 | db: config.DB_DATABASE,
48 | min: 10,
49 | max: 50
50 | });
51 | });
52 |
53 | // For custom RethinkDB queries, register the "r" object that comes from rethinkdbdash
54 | container.register('r', function (rethinkdbAdapter) {
55 | return rethinkdbAdapter.r;
56 | });
57 |
58 | // Register the a new data store with the container
59 | container.register('DS', function (container, rethinkdbAdapter) {
60 | var JSData = require('js-data');
61 | var store = new JSData.DS({
62 | cacheResponse: false,
63 | bypassCache: true,
64 |
65 | // Important: If your relationships stop working, you might
66 | // have deleted this.
67 | linkRelations: false,
68 |
69 | // Because
70 | upsert: false,
71 |
72 | // Don't really need this stuff on the server, so let's improve
73 | // performance and disable these features
74 | notify: false,
75 | keepChangeHistory: false,
76 | resetHistoryOnInject: false,
77 |
78 | // Here you could set "log" to a function of your own, for
79 | // debugging or to hook it into your own logging code.
80 | // You would the same with the "error" option.
81 | log: false
82 | });
83 |
84 | // Register the rethinkdb adapter as the default adapter
85 | store.registerAdapter('rethinkdb', rethinkdbAdapter, {'default': true});
86 |
87 | return store;
88 | });
89 |
90 | // Automatically load and register the modules in these folders
91 | container.load(path.join(__dirname, './controllers'));
92 | container.load(path.join(__dirname, './middleware'));
93 | container.load(path.join(__dirname, './models'));
94 | container.load(path.join(__dirname, './lib'));
95 |
96 | // Register the container with the container, useful for when you need dynamically resolve a dependency or avoid a circular dependency
97 | container.register('container', function () {
98 | return container;
99 | });
100 |
101 | module.exports = container;
102 |
--------------------------------------------------------------------------------
/server/rethinkdb/app/controllers/comments.js:
--------------------------------------------------------------------------------
1 | module.exports = function (Comment) {
2 |
3 | return {
4 | /**
5 | * GET /comments
6 | */
7 | findAll: function (req, res) {
8 | return Comment.findAll(req.query, {'with': ['user']}).then(function (comments) {
9 | return res.status(200).send(comments).end();
10 | });
11 | },
12 |
13 | /**
14 | * POST /comments
15 | */
16 | createOne: function (req, res) {
17 | var comment = Comment.createInstance(req.body);
18 | comment.owner_id = req.user.id;
19 | return Comment.create(comment, {'with': ['user']}).then(function (comment) {
20 | return res.status(201).send(comment).end();
21 | });
22 | },
23 |
24 | /**
25 | * PUT /comments/:id
26 | */
27 | updateOneById: function (req, res, next) {
28 | return Comment.find(req.params.id).then(function (comment) {
29 | if (comment.owner_id !== req.user.id) {
30 | return next(404);
31 | } else {
32 | return Comment.update(comment.id, req.body).then(function (comment) {
33 | return res.status(200).send(comment).end();
34 | });
35 | }
36 | });
37 | },
38 |
39 | /**
40 | * DELETE /comments/:id
41 | */
42 | deleteOneById: function (req, res, next) {
43 | return Comment.find(req.params.id).then(function (comment) {
44 | if (comment.owner_id !== req.user.id) {
45 | return next(404);
46 | } else {
47 | return Comment.destroy(comment.id).then(function () {
48 | return res.status(204).end();
49 | });
50 | }
51 | });
52 | }
53 | };
54 | };
55 |
--------------------------------------------------------------------------------
/server/rethinkdb/app/controllers/posts.js:
--------------------------------------------------------------------------------
1 | module.exports = function (Post) {
2 |
3 | return {
4 | /**
5 | * GET /posts
6 | */
7 | findAll: function (req, res) {
8 | return Post.findAll(req.query).then(function (posts) {
9 | return res.status(200).send(posts).end();
10 | });
11 | },
12 |
13 | /**
14 | * GET /posts/:id
15 | */
16 | findOneById: function (req, res) {
17 | return Post.find(req.params.id, {'with': ['user']}).then(function (post) {
18 | return res.status(200).send(post).end();
19 | });
20 | },
21 |
22 | /**
23 | * POST /posts
24 | */
25 | createOne: function (req, res) {
26 | var post = Post.createInstance(req.body);
27 | post.owner_id = req.user.id;
28 | return Post.create(post, {'with': ['user']}).then(function (post) {
29 | return res.status(201).send(post).end();
30 | });
31 | },
32 |
33 | /**
34 | * PUT /posts/:id
35 | */
36 | updateOneById: function (req, res, next) {
37 | return Post.find(req.params.id).then(function (post) {
38 | if (post.owner_id !== req.user.id) {
39 | return next(404);
40 | } else {
41 | return Post.update(post.id, req.body).then(function (post) {
42 | return res.status(200).send(post).end();
43 | });
44 | }
45 | });
46 | },
47 |
48 | /**
49 | * DELETE /posts/:id
50 | */
51 | deleteOneById: function (req, res, next) {
52 | return Post.find(req.params.id).then(function (post) {
53 | if (post.owner_id !== req.user.id) {
54 | return next(404);
55 | } else {
56 | return Post.destroy(post.id).then(function () {
57 | return res.status(204).end();
58 | });
59 | }
60 | });
61 | }
62 | };
63 | };
64 |
--------------------------------------------------------------------------------
/server/rethinkdb/app/controllers/users.js:
--------------------------------------------------------------------------------
1 | module.exports = function (User) {
2 |
3 | return {
4 | /**
5 | * GET /users
6 | */
7 | findAll: function (req, res) {
8 | return User.findAll(req.query).then(function (users) {
9 | return res.status(200).send(users).end();
10 | });
11 | },
12 |
13 | /**
14 | * GET /users/:id
15 | */
16 | findOneById: function (req, res) {
17 | return User.find(req.params.id, {'with': ['post', 'comment']}).then(function (user) {
18 | user.posts = user.posts || [];
19 | user.comments = user.comments || [];
20 | // only return up to 10 comments
21 | user.comments.slice(0, 10);
22 | return res.status(200).send(user).end();
23 | });
24 | }
25 | };
26 | };
27 |
--------------------------------------------------------------------------------
/server/rethinkdb/app/default.config.js:
--------------------------------------------------------------------------------
1 | // Change as necessary
2 | module.exports = {
3 | // Port Express will listen to
4 | PORT: 3000,
5 |
6 | // Rethinkdb configuration
7 | DB_HOST: '127.0.0.1',
8 | DB_PORT: 28015,
9 | DB_DATABASE: 'jsdata',
10 |
11 | // Login won't work without these
12 | GITHUB_CLIENT_ID: '',
13 | GITHUB_CLIENT_SECRET: '',
14 |
15 | GITHUB_CALLBACK_URL: '',
16 | };
17 |
--------------------------------------------------------------------------------
/server/sql/.gitignore:
--------------------------------------------------------------------------------
1 | node_modules/
2 | bower_components/
3 |
4 | .idea/
5 |
6 | *.iml
7 |
8 | coverage/
9 |
10 | rethinkdb_data/
11 |
12 | local.config.js
13 |
14 | server/sql/.git/
15 |
16 | node_modules
17 |
18 | npm-debug.log
19 |
--------------------------------------------------------------------------------
/server/sql/Procfile:
--------------------------------------------------------------------------------
1 | web: node app/app.js
2 |
--------------------------------------------------------------------------------
/server/sql/README.md:
--------------------------------------------------------------------------------
1 |
2 |
3 | ## server-side js-data w/sql
4 |
--------------------------------------------------------------------------------
/server/sql/app/app.js:
--------------------------------------------------------------------------------
1 | var express = require('express');
2 | var http = require('http');
3 | var bodyParser = require('body-parser');
4 | var cookieParser = require('cookie-parser');
5 | var session = require('express-session');
6 | var methodOverride = require('method-override');
7 | var GitHubStrategy = require('passport-github').Strategy;
8 | var path = require('path');
9 | var container = require('./container');
10 |
11 | // This allows us to programmatically start the app in a test environment
12 | exports.createServer = function () {
13 |
14 | // Bootstrap the application, injecting a bunch of dependencies
15 | return container.resolve(function (User, safeCall, users, posts, comments, errorHandler, queryRewrite, rewriteRelations, passport, config) {
16 | var app = express();
17 |
18 | // Simple route middleware to ensure user is authenticated.
19 | // Use this route middleware on any resource that needs to be protected. If
20 | // the request is authenticated (typically via a persistent login session),
21 | // the request will proceed. Otherwise, the user will be redirected to the
22 | // login page.
23 | function ensureAuthenticated(req, res, next) {
24 | if (req.isAuthenticated()) {
25 | return next();
26 | }
27 | res.redirect('/login');
28 | }
29 |
30 | function renderIndex(req, res, next) {
31 | res.render('index.html', {}, function (err, html) {
32 | if (err) {
33 | next(err);
34 | } else {
35 | res.status(200).send(html).end();
36 | }
37 | });
38 | }
39 |
40 | passport.serializeUser(function (user, done) {
41 | done(null, user);
42 | });
43 |
44 | passport.deserializeUser(function (user, done) {
45 | done(null, user);
46 | });
47 |
48 | // Use the GitHubStrategy within Passport.
49 | // Strategies in Passport require a `verify` function, which accept
50 | // credentials (in this case, an accessToken, refreshToken, and GitHub
51 | // profile), and invoke a callback with a user object.
52 | passport.use(new GitHubStrategy({
53 | clientID: config.GITHUB_CLIENT_ID,
54 | clientSecret: config.GITHUB_CLIENT_SECRET,
55 | callbackURL: config.GITHUB_CALLBACK_URL
56 | },
57 | function (accessToken, refreshToken, profile, done) {
58 | User.findAll({
59 | github_id: profile.id
60 | }).then(function (users) {
61 | if (users.length) {
62 | return users[0];
63 | } else {
64 | return User.create({
65 | username: profile.username,
66 | avatar_url: profile._json.avatar_url,
67 | github_id: profile.id,
68 | name: profile.displayName,
69 | created_at: new Date()
70 | });
71 | }
72 | }).then(function (user) {
73 | return done(null, user);
74 | }).catch(function (err) {
75 | done(err);
76 | });
77 | }
78 | ));
79 |
80 | // middleware
81 | app.use(queryRewrite);
82 | app.use(rewriteRelations);
83 | app.use(bodyParser.json());
84 | app.use(cookieParser());
85 | app.use(bodyParser.urlencoded({extended: true}));
86 | app.use(methodOverride());
87 |
88 | // I'm only using Express to render/serve the index.html file and other static assets for simplicity with the example apps
89 | app.set('views', path.resolve(config.PUBLIC_PATH));
90 | app.set('view engine', 'ejs');
91 | app.engine('html', require('ejs').renderFile);
92 |
93 | // Using Express/Passports for simplicity in the example. I would never use this in production.
94 | app.use(session({secret: 'keyboard cat'}));
95 | app.use(passport.initialize());
96 | app.use(passport.session());
97 | // PUBLIC_PATH is used to choose with frontend client to use. Default is the js-data + Angular client.
98 | app.use(express.static(path.resolve(config.PUBLIC_PATH)));
99 |
100 | // app settings
101 | app.enable('trust proxy');
102 |
103 | app.get('/', renderIndex);
104 |
105 | /******************************/
106 | /********** comments **********/
107 | /******************************/
108 | app.route('/api/comments')
109 | // GET /comments
110 | .get(safeCall(comments.findAll))
111 | // POST /comments
112 | .post(ensureAuthenticated, safeCall(comments.createOne));
113 |
114 | app.route('/api/comments/:id')
115 | .put(ensureAuthenticated, safeCall(comments.updateOneById))
116 | .delete(ensureAuthenticated, safeCall(comments.deleteOneById));
117 |
118 | /*******************************/
119 | /********** posts **************/
120 | /*******************************/
121 | app.route('/api/posts')
122 | .get(safeCall(posts.findAll))
123 | .post(ensureAuthenticated, safeCall(posts.createOne));
124 |
125 | app.route('/api/posts/:id')
126 | .get(safeCall(posts.findOneById))
127 | .put(ensureAuthenticated, safeCall(posts.updateOneById))
128 | .delete(ensureAuthenticated, safeCall(posts.deleteOneById));
129 |
130 | /*******************************/
131 | /********** users **************/
132 | /*******************************/
133 | app.get('/api/users/loggedInUser', function (req, res) {
134 | if (req.isAuthenticated()) {
135 | return res.json(req.user);
136 | } else {
137 | res.send();
138 | }
139 | });
140 |
141 | app.route('/api/users')
142 | .get(safeCall(users.findAll));
143 |
144 | app.route('/api/users/:id')
145 | .get(safeCall(users.findOneById));
146 |
147 | // Normally I would have a bunch of user-related routes, but I'm
148 | // just using Passport.js + Github for simplicity in the example
149 |
150 | /*******************************/
151 | /*********** auth **************/
152 | /*******************************/
153 | app.get('/auth/github', passport.authenticate('github'));
154 | app.get('/auth/github/callback', passport.authenticate('github', {failureRedirect: '/login'}), function (req, res) {
155 | res.redirect('/');
156 | });
157 | app.post('/api/logout', function (req, res) {
158 | req.logout();
159 | res.redirect('/');
160 | });
161 |
162 | // Redirect all others to the index (HTML5 history)
163 | app.get('*', function (req, res, next) {
164 | if (req.originalUrl.indexOf('socket.io') === -1) {
165 | renderIndex(req, res, next);
166 | } else {
167 | next();
168 | }
169 | });
170 |
171 | // Catch-all error handler
172 | app.use(function (err, req, res, next) {
173 | errorHandler(err, req, res, next);
174 | });
175 |
176 | return app;
177 | });
178 | };
179 |
180 | // This allows us to programmatically start the app in a test environment
181 | if (module === require.main || process.env.NODE_ENV === 'prod') {
182 | var app = exports.createServer();
183 | var server = http.createServer(app);
184 | var config = container.get('config');
185 |
186 | // Add a socket server to be used as a message bus for the clients
187 | var io = require('socket.io').listen(server);
188 |
189 | server.listen(config.PORT);
190 |
191 | container.register('io', function () {
192 | return io;
193 | });
194 |
195 | var query = container.get('query');
196 |
197 | query.schema.hasTable('users').then(function (exists) {
198 | if (!exists) {
199 | return query.schema.createTable('users', function (t) {
200 | t.increments('id').primary();
201 | t.string('username');
202 | t.string('name');
203 | t.integer('github_id').unsigned();
204 | t.string('avatar_url');
205 | t.timestamps();
206 | });
207 | }
208 | }).then(function () {
209 | return query.schema.hasTable('posts');
210 | }).then(function (exists) {
211 | if (!exists) {
212 | return query.schema.createTable('posts', function (t) {
213 | t.increments('id').primary();
214 | t.integer('owner_id').unsigned().references('id').inTable('users');
215 | t.string('title');
216 | t.text('body');
217 | t.timestamps();
218 | });
219 | }
220 | }).then(function () {
221 | return query.schema.hasTable('comments');
222 | }).then(function (exists) {
223 | if (!exists) {
224 | return query.schema.createTable('comments', function (t) {
225 | t.increments('id').primary();
226 | t.integer('post_id').unsigned().references('id').inTable('posts');
227 | t.integer('owner_id').unsigned().references('id').inTable('users');
228 | t.text('body');
229 | t.timestamps();
230 | });
231 | }
232 | }).catch(function (err) {
233 | console.log(err);
234 | });
235 | }
236 |
--------------------------------------------------------------------------------
/server/sql/app/container.js:
--------------------------------------------------------------------------------
1 | // dependable is and IOC container library
2 | // we register components with the container, and modules declare dependencies that they need injected
3 | var dependable = require('dependable');
4 | var path = require('path');
5 |
6 | var container = dependable.container();
7 |
8 | // Load and register app config
9 | container.register('config', function () {
10 | return {
11 | PORT: process.env.PORT || 3000,
12 |
13 | // database configuration
14 | DB_CLIENT: process.env.DB_CLIENT || 'mysql', // or "pg" or "sqlite3"
15 | DB_HOST: process.env.DB_HOST || '127.0.0.1',
16 | DB_PORT: process.env.DB_PORT || 3306,
17 | DB_DATABASE: process.env.DB_DATABASE || 'jsdata',
18 | DB_USER: process.env.DB_USER || 'root',
19 | DB_PASSWORD: process.env.DB_PASSWORD || '',
20 |
21 | // Login won't work without these
22 | GITHUB_CLIENT_ID: process.env.GITHUB_CLIENT_ID || '',
23 | GITHUB_CLIENT_SECRET: process.env.GITHUB_CLIENT_SECRET || '',
24 |
25 | GITHUB_CALLBACK_URL: process.env.GITHUB_CALLBACK_URL || 'http://127.0.0.1:3000/auth/github/callback',
26 |
27 | // Default to using the js-data + angular example for the client.
28 | PUBLIC_PATH: process.env.PUBLIC_PATH || '../../../client/angular'
29 | };
30 | });
31 |
32 | // 3rd-party dependencies
33 | // Anything registered with the container becomes trivial to mock in tests
34 | container.register('mout', function () {
35 | return require('mout');
36 | });
37 | container.register('Promise', function () {
38 | return require('bluebird');
39 | });
40 | container.register('passport', function () {
41 | return require('passport');
42 | });
43 |
44 | // Create and register a js-data-sql adapter with the container
45 | container.register('sqlAdapter', function (config) {
46 | var DSSqlAdapter = require('js-data-sql');
47 | return new DSSqlAdapter({
48 | client: config.DB_CLIENT,
49 | connection: {
50 | host: config.DB_HOST,
51 | user: config.DB_USER,
52 | password: config.DB_PASSWORD,
53 | database: config.DB_DATABASE,
54 | port: config.DB_PORT
55 | }
56 | });
57 | });
58 |
59 | // For custom SQL queries, register the "query" object that comes from the adapter
60 | container.register('query', function (sqlAdapter) {
61 | return sqlAdapter.query;
62 | });
63 |
64 | // Automatically load and register the modules in these folders
65 | container.load(path.join(__dirname, './controllers'));
66 | container.load(path.join(__dirname, './middleware'));
67 | container.load(path.join(__dirname, './models'));
68 | container.load(path.join(__dirname, './lib'));
69 |
70 | // Register the a new data store with the container
71 | container.register('DS', function (Promise, container, sqlAdapter, messageService) {
72 | var JSData = require('js-data');
73 | JSData.DSUtils.Promise = Promise;
74 | var store = new JSData.DS({
75 | cacheResponse: false,
76 | bypassCache: true,
77 |
78 | // Important: If your relationships stop working, you might
79 | // have deleted this.
80 | linkRelations: false,
81 |
82 | // Because
83 | upsert: false,
84 |
85 | // Don't really need this stuff on the server, so let's improve
86 | // performance and disable these features
87 | notify: false,
88 | keepChangeHistory: false,
89 | resetHistoryOnInject: false,
90 |
91 | // Here you could set "log" to a function of your own, for
92 | // debugging or to hook it into your own logging code.
93 | // You would the same with the "error" option.
94 | log: false,
95 |
96 | beforeCreate: function (Resource, instance, cb) {
97 | instance.created_at = new Date();
98 | instance.updated_at = new Date();
99 | return cb(null, instance);
100 | },
101 |
102 | beforeUpdate: function (Resource, instance, cb) {
103 | instance.updated_at = new Date();
104 | return cb(null, instance);
105 | },
106 |
107 | afterCreate: function (Resource, instance, cb) {
108 | messageService.sendCreateMessage(Resource.name, instance);
109 | cb(null, instance);
110 | },
111 |
112 | afterUpdate: function (Resource, instance, cb) {
113 | messageService.sendUpdateMessage(Resource.name, instance);
114 | cb(null, instance);
115 | },
116 |
117 | afterDestroy: function (Resource, instance, cb) {
118 | messageService.sendDestroyMessage(Resource.name, instance);
119 | cb(null, instance);
120 | }
121 | });
122 |
123 | // Register the sql adapter as the default adapter
124 | store.registerAdapter('sql', sqlAdapter, {'default': true});
125 |
126 | return store;
127 | });
128 |
129 | // Register the container with the container, useful for when you need dynamically resolve a dependency or avoid a circular dependency
130 | container.register('container', function () {
131 | return container;
132 | });
133 |
134 | module.exports = container;
135 |
--------------------------------------------------------------------------------
/server/sql/app/controllers/comments.js:
--------------------------------------------------------------------------------
1 | module.exports = function (Comment) {
2 |
3 | return {
4 | /**
5 | * GET /comments
6 | */
7 | findAll: function (req, res) {
8 | return Comment.findAll(req.query, {'with': ['user']}).then(function (comments) {
9 | return res.status(200).send(comments).end();
10 | });
11 | },
12 |
13 | /**
14 | * POST /comments
15 | */
16 | createOne: function (req, res) {
17 | var comment = Comment.createInstance(req.body);
18 | comment.owner_id = req.user.id;
19 | return Comment.create(comment, {'with': ['user']}).then(function (comment) {
20 | return res.status(201).send(comment).end();
21 | });
22 | },
23 |
24 | /**
25 | * PUT /comments/:id
26 | */
27 | updateOneById: function (req, res, next) {
28 | return Comment.find(req.params.id).then(function (comment) {
29 | if (comment.owner_id !== req.user.id) {
30 | return next(404);
31 | } else {
32 | return Comment.update(comment.id, req.body).then(function (comment) {
33 | return res.status(200).send(comment).end();
34 | });
35 | }
36 | });
37 | },
38 |
39 | /**
40 | * DELETE /comments/:id
41 | */
42 | deleteOneById: function (req, res, next) {
43 | return Comment.find(req.params.id).then(function (comment) {
44 | if (comment.owner_id !== req.user.id) {
45 | return next(404);
46 | } else {
47 | return Comment.destroy(comment.id).then(function () {
48 | return res.status(204).end();
49 | });
50 | }
51 | });
52 | }
53 | };
54 | };
55 |
--------------------------------------------------------------------------------
/server/sql/app/controllers/posts.js:
--------------------------------------------------------------------------------
1 | module.exports = function (Post) {
2 |
3 | return {
4 | /**
5 | * GET /posts
6 | */
7 | findAll: function (req, res) {
8 | return Post.findAll(req.query).then(function (posts) {
9 | return res.status(200).send(posts).end();
10 | });
11 | },
12 |
13 | /**
14 | * GET /posts/:id
15 | */
16 | findOneById: function (req, res) {
17 | return Post.find(req.params.id, {'with': ['user', 'comment']}).then(function (post) {
18 | return res.status(200).send(post).end();
19 | });
20 | },
21 |
22 | /**
23 | * POST /posts
24 | */
25 | createOne: function (req, res) {
26 | var post = Post.createInstance(req.body);
27 | post.owner_id = req.user.id;
28 | return Post.create(post, {'with': ['user']}).then(function (post) {
29 | return res.status(201).send(post).end();
30 | });
31 | },
32 |
33 | /**
34 | * PUT /posts/:id
35 | */
36 | updateOneById: function (req, res, next) {
37 | return Post.find(req.params.id).then(function (post) {
38 | if (post.owner_id !== req.user.id) {
39 | return next(404);
40 | } else {
41 | return Post.update(post.id, req.body).then(function (post) {
42 | return res.status(200).send(post).end();
43 | });
44 | }
45 | });
46 | },
47 |
48 | /**
49 | * DELETE /posts/:id
50 | */
51 | deleteOneById: function (req, res, next) {
52 | return Post.find(req.params.id).then(function (post) {
53 | if (post.owner_id !== req.user.id) {
54 | return next(404);
55 | } else {
56 | return Post.destroy(post.id).then(function () {
57 | return res.status(204).end();
58 | });
59 | }
60 | });
61 | }
62 | };
63 | };
64 |
--------------------------------------------------------------------------------
/server/sql/app/controllers/users.js:
--------------------------------------------------------------------------------
1 | module.exports = function (User) {
2 |
3 | return {
4 | /**
5 | * GET /users
6 | */
7 | findAll: function (req, res) {
8 | return User.findAll(req.query).then(function (users) {
9 | return res.status(200).send(users).end();
10 | });
11 | },
12 |
13 | /**
14 | * GET /users/:id
15 | */
16 | findOneById: function (req, res) {
17 | return User.find(req.params.id, {'with': ['post', 'comment']}).then(function (user) {
18 | user.posts = user.posts || [];
19 | user.comments = user.comments || [];
20 | // only return up to 10 comments
21 | user.comments.slice(0, 10);
22 | return res.status(200).send(user).end();
23 | });
24 | }
25 | };
26 | };
27 |
--------------------------------------------------------------------------------
/server/sql/app/lib/messageService.js:
--------------------------------------------------------------------------------
1 | // Our service for broadcasting messages to connected clients.
2 | // A way of implementing a sort of "3-way binding"
3 | module.exports = function (container) {
4 |
5 | function sendMessage(event, resource, instance) {
6 | var io = container.get('io');
7 | var message = {
8 | id: instance.id,
9 | owner_id: instance.owner_id,
10 | resource: resource,
11 | event: event
12 | };
13 | io.sockets.emit(event, message);
14 | }
15 |
16 | return {
17 | sendCreateMessage: function (resource, instance) {
18 | sendMessage('create', resource, instance);
19 | },
20 |
21 | sendDestroyMessage: function (resource, instance) {
22 | sendMessage('destroy', resource, instance);
23 | },
24 |
25 | sendUpdateMessage: function (resource, instance) {
26 | sendMessage('update', resource, instance);
27 | }
28 | };
29 | };
30 |
--------------------------------------------------------------------------------
/server/sql/app/lib/safeCall.js:
--------------------------------------------------------------------------------
1 | // This little generator simply saves us a lot of boilerplate code
2 | module.exports = function (Promise) {
3 | function safeCall(method) {
4 | return function (req, res, next) {
5 | return Promise.try(function () {
6 | return method(req, res, next);
7 | }).catch(next).error(next);
8 | };
9 | }
10 |
11 | return safeCall;
12 | };
13 |
--------------------------------------------------------------------------------
/server/sql/app/middleware/errorHandler.js:
--------------------------------------------------------------------------------
1 | module.exports = function () {
2 | var JSData = require('js-data');
3 | var IllegalArgumentError = JSData.DSErrors.IllegalArgumentError;
4 | var RuntimeError = JSData.DSErrors.RuntimeError;
5 | return function (err, req, res) {
6 | var responder;
7 | if (err && req) {
8 | if (res) {
9 | // Normally you would be using some logging library
10 | console.log(err.message);
11 | console.log(err.stack);
12 | }
13 | }
14 | if (req && typeof req.send === 'function') {
15 | responder = req;
16 | } else if (res && typeof res.send === 'function') {
17 | responder = res;
18 | }
19 | if (err instanceof IllegalArgumentError) {
20 | responder.status(400).send(err.errors || err.message).end();
21 | } else if (err instanceof RuntimeError) {
22 | responder.status(500).send(err.errors || err.message).end();
23 | } else if (err === 'Not Found!' || (err.message && err.message === 'Not Found!')) {
24 | responder.status(404).end();
25 | } else if (typeof err === 'number') {
26 | responder.status(err).end();
27 | } else if (typeof err === 'object') {
28 | responder.status(400).send(err).end();
29 | } else {
30 | responder.status(500).send({ error: '500 - Internal Server Error' }).end();
31 | }
32 | };
33 | };
34 |
--------------------------------------------------------------------------------
/server/sql/app/middleware/queryRewrite.js:
--------------------------------------------------------------------------------
1 | // This is to fully parse the JSON in req.query
2 | module.exports = function () {
3 | return function (req, res, next) {
4 | if (req.query.where) {
5 | try {
6 | var where = JSON.parse(req.query.where);
7 | for (var key in where) {
8 | if (typeof where[key] === 'object' && '==' in where[key]) {
9 | where[key] = where[key]['=='];
10 | }
11 | }
12 | req.query.where = where;
13 | next();
14 | } catch (err) {
15 | next(err);
16 | }
17 | } else {
18 | next();
19 | }
20 | };
21 | };
22 |
--------------------------------------------------------------------------------
/server/sql/app/middleware/rewriteRelations.js:
--------------------------------------------------------------------------------
1 | // Removes 'with' from the query and saves it separately on the request. This
2 | // lets us use syntax like the following:
3 | // DS.findAll('user', req.query, { with: req.with });
4 | // DS.find('user', 5, { with: req.with })
5 | module.exports = function() {
6 | return function rewriteRelations(req, res, next) {
7 | if ('with' in req.query) {
8 | req.with = Array.isArray(req.query.with) ? req.query.with : [req.query.with];
9 | delete req.query.with;
10 | }
11 | else {
12 | req.with = [];
13 | }
14 |
15 | next();
16 | };
17 | };
18 |
--------------------------------------------------------------------------------
/server/sql/app/models/Comment.js:
--------------------------------------------------------------------------------
1 | module.exports = function (container, Promise, mout, messageService, config, DS) {
2 | if (DS.definitions.comment) {
3 | return DS.definitions.comment;
4 | }
5 |
6 | return DS.defineResource({
7 | name: 'comment',
8 | table: 'comments',
9 | relations: {
10 | belongsTo: {
11 | user: {
12 | localField: 'user',
13 | localKey: 'owner_id'
14 | },
15 | post: {
16 | localField: 'post',
17 | localKey: 'post_id'
18 | }
19 | }
20 | }
21 | });
22 | };
23 |
--------------------------------------------------------------------------------
/server/sql/app/models/Post.js:
--------------------------------------------------------------------------------
1 | module.exports = function (container, Promise, mout, messageService, config, DS) {
2 | if (DS.definitions.post) {
3 | return DS.definitions.post;
4 | }
5 |
6 | return DS.defineResource({
7 | name: 'post',
8 | table: 'posts',
9 | relations: {
10 | belongsTo: {
11 | user: {
12 | localField: 'user',
13 | localKey: 'owner_id'
14 | }
15 | },
16 | hasMany: {
17 | comment: {
18 | localField: 'comments',
19 | foreignKey: 'post_id'
20 | }
21 | }
22 | }
23 | });
24 | };
25 |
--------------------------------------------------------------------------------
/server/sql/app/models/User.js:
--------------------------------------------------------------------------------
1 | module.exports = function (container, Promise, mout, messageService, config, DS) {
2 | if (DS.definitions.user) {
3 | return DS.definitions.user;
4 | }
5 |
6 | return DS.defineResource({
7 | name: 'user',
8 | table: 'users',
9 | relations: {
10 | hasMany: {
11 | post: {
12 | localField: 'posts',
13 | foreignKey: 'owner_id'
14 | },
15 | comment: {
16 | localField: 'comments',
17 | foreignKey: 'owner_id'
18 | }
19 | }
20 | }
21 | });
22 | };
23 |
--------------------------------------------------------------------------------
/server/sql/package.json:
--------------------------------------------------------------------------------
1 | {
2 | "name": "js-data-sql-example",
3 | "description": "js-data + js-data-sql",
4 | "version": "1.1.0",
5 | "homepage": "http://www.js-data.io/docs/dssqladapter",
6 | "repository": {
7 | "type": "git",
8 | "url": "https://github.com/js-data/js-data-examples.git"
9 | },
10 | "author": {
11 | "name": "Jason Dobry",
12 | "email": "jason.dobry@gmail.com"
13 | },
14 | "license": "MIT",
15 | "keywords": [
16 | "data",
17 | "datastore",
18 | "store",
19 | "database",
20 | "adapter",
21 | "sql",
22 | "mysql",
23 | "postgresql",
24 | "mariadb",
25 | "sqlite"
26 | ],
27 | "scripts": {
28 | "start": "node app/app.js"
29 | },
30 | "private": true,
31 | "dependencies": {
32 | "bluebird": "2.9.34",
33 | "body-parser": "1.13.2",
34 | "cookie-parser": "1.3.5",
35 | "dependable": "0.2.5",
36 | "ejs": "2.3.3",
37 | "express": "4.13.1",
38 | "express-session": "1.11.3",
39 | "js-data": "2.2.2",
40 | "js-data-sql": "0.9.2",
41 | "knex": "0.8.6",
42 | "mariasql": "0.1.23",
43 | "method-override": "2.3.4",
44 | "mout": "0.11.0",
45 | "mysql": "2.8.0",
46 | "passport": "0.2.2",
47 | "passport-github": "0.1.5",
48 | "pg": "4.4.0",
49 | "socket.io": "1.3.6",
50 | "sqlite3": "3.0.9"
51 | }
52 | }
53 |
--------------------------------------------------------------------------------
/server/src/adapters/index.js:
--------------------------------------------------------------------------------
1 | 'use strict'
2 |
3 | module.exports = function (adapter) {
4 | return require(`./${adapter}`)
5 | }
6 |
--------------------------------------------------------------------------------
/server/src/adapters/mongodb.js:
--------------------------------------------------------------------------------
1 | 'use strict'
2 |
3 | const MongoDBAdapter = require('js-data-mongodb').MongoDBAdapter
4 | const nconf = require('nconf')
5 |
6 | const adapter = exports.adapter = new MongoDBAdapter()
7 |
--------------------------------------------------------------------------------
/server/src/adapters/mysql.js:
--------------------------------------------------------------------------------
1 | 'use strict'
2 |
3 | const SqlAdapter = require('js-data-sql').SqlAdapter
4 | const nconf = require('nconf')
5 |
6 | const adapter = exports.adapter = new SqlAdapter({
7 | knexOpts: {
8 | client: 'mysql',
9 | host: nconf.get('DB_HOST'),
10 | port: nconf.get('DB_PORT'),
11 | db: nconf.get('DB')
12 | }
13 | })
14 |
--------------------------------------------------------------------------------
/server/src/adapters/postgres.js:
--------------------------------------------------------------------------------
1 | 'use strict'
2 |
3 | const SqlAdapter = require('js-data-sql').SqlAdapter
4 | const nconf = require('nconf')
5 |
6 | const adapter = exports.adapter = new SqlAdapter({
7 | knexOpts: {
8 | client: 'pg',
9 | host: nconf.get('DB_HOST'),
10 | port: nconf.get('DB_PORT'),
11 | db: nconf.get('DB')
12 | }
13 | })
14 |
--------------------------------------------------------------------------------
/server/src/adapters/rethinkdb.js:
--------------------------------------------------------------------------------
1 | 'use strict'
2 |
3 | const RethinkDBAdapter = require('js-data-rethinkdb').RethinkDBAdapter
4 | const nconf = require('nconf')
5 |
6 | const adapter = exports.adapter = new RethinkDBAdapter({
7 | rOpts: {
8 | host: nconf.get('DB_HOST') || 'localhost',
9 | port: nconf.get('DB_PORT') || 28015,
10 | db: nconf.get('DB') || 'blog'
11 | }
12 | })
13 |
--------------------------------------------------------------------------------
/server/src/adapters/sqlite.js:
--------------------------------------------------------------------------------
1 | 'use strict'
2 |
3 | const SqlAdapter = require('js-data-sql').SqlAdapter
4 | const nconf = require('nconf')
5 |
6 | const adapter = exports.adapter = new SqlAdapter({
7 | knexOpts: {
8 | client: 'sqlite3',
9 | host: nconf.get('DB_HOST'),
10 | port: nconf.get('DB_PORT'),
11 | db: nconf.get('DB')
12 | }
13 | })
14 |
--------------------------------------------------------------------------------
/server/src/index.js:
--------------------------------------------------------------------------------
1 | 'use strict'
2 |
3 | require('source-map-support').install()
4 | const Promise = require('bluebird')
5 | const JSData = require('js-data')
6 | const express = require('express')
7 | const nconf = require('nconf')
8 |
9 | // 1. Pull config from the commandline arguments
10 | // 2. Pull config from environment variables
11 | // 3. Pull config from a config file
12 | nconf.argv().env().file({ file: `${__dirname}/../config.json` })
13 |
14 | // Make JSData use bluebird internally
15 | JSData.utils.Promise = Promise
16 |
17 | const utils = require('./utils')
18 | const middleware = require('./middleware')
19 | const store = require('./store').store
20 | const app = express()
21 |
22 | const PAGE_SIZE = 5
23 |
24 | // Application middleware
25 | app.use(require('body-parser').json())
26 | app.use(require('express-session')({ secret: 'keyboard cat' }))
27 | app.use(middleware.passport.initialize())
28 | app.use(middleware.passport.session())
29 | app.use(express.static(`${__dirname}/../../client/public`))
30 | app.use(middleware.queryRewrite)
31 |
32 | // Application routes
33 | app.get('/api/users/loggedInUser', function (req, res) {
34 | if (req.isAuthenticated()) {
35 | res.json(req.user)
36 | }
37 | res.end()
38 | })
39 |
40 | app.get('/api/posts', utils.makeSafe(function (req, res, next) {
41 | req.query.limit = req.query.limit === undefined ? PAGE_SIZE : req.query.limit
42 | req.query.offset = req.query.offset === undefined ? 0 : req.query.offset
43 | const currentPage = (req.query.offset / PAGE_SIZE) + 1
44 |
45 | Promise.all([
46 | store.count('post'),
47 | store.findAll('post', req.query)
48 | ]).spread(function (totalNumPosts, posts) {
49 | return {
50 | page: currentPage,
51 | data: posts,
52 | total: totalNumPosts
53 | }
54 | }).then(res.send.bind(res))
55 | }))
56 | app.post('/api/posts', utils.makeSafe(function (req, res, next) {
57 | return store.create('post', {
58 | title: req.body.title,
59 | content: req.body.content
60 | }).then(res.send.bind(res))
61 | }))
62 | app.get('/api/posts/:id', utils.makeSafe(function (req, res, next) {
63 | return store.find('post', req.params.id, { with: ['comment'] }).then(res.send.bind(res))
64 | }))
65 |
66 | app.get('/auth/github', middleware.passport.authenticate('github'))
67 | app.get('/auth/github/callback', middleware.passport.authenticate('github', { failureRedirect: '/login' }), function (req, res) {
68 | res.redirect('/')
69 | })
70 | app.post('/api/logout', function (req, res) {
71 | req.logout()
72 | res.redirect('/')
73 | })
74 |
75 | // Serve index.html if no other route was matched
76 | app.get('*', middleware.indexRoute)
77 |
78 | // Generic catch-all error handler
79 | app.use(middleware.errorHandler)
80 |
81 | // Start the Express server
82 | const server = app.listen(process.env.PORT || 3000, '0.0.0.0', function () {
83 | const address = server.address().address
84 | const port = server.address().port
85 | console.log('App listening at http://%s:%s', address, port)
86 | console.log('Press Ctrl+C to quit.')
87 | })
88 |
--------------------------------------------------------------------------------
/server/src/middleware.js:
--------------------------------------------------------------------------------
1 | 'use strict'
2 |
3 | const passport = require('passport')
4 | const GitHubStrategy = require('passport-github').Strategy
5 | const nconf = require('nconf')
6 | const store = require('./store').store
7 |
8 | passport.serializeUser(function (user, done) { done(null, user) })
9 | passport.deserializeUser(function (obj, done) { done(null, obj) })
10 | passport.use(new GitHubStrategy({
11 | clientID: nconf.get('GITHUB_CLIENT_ID'),
12 | clientSecret: nconf.get('GITHUB_CLIENT_SECRET'),
13 | callbackURL: nconf.get('GITHUB_CALLBACK_URL')
14 | }, function (accessToken, refreshToken, profile, done) {
15 | store.findAll('user', {
16 | github_id: profile.id
17 | }).then(function (users) {
18 | if (users.length) {
19 | return users[0]
20 | } else {
21 | return store.create('user', {
22 | username: profile.username,
23 | avatar_url: profile._json.avatar_url,
24 | github_id: profile.id,
25 | name: profile.displayName
26 | })
27 | }
28 | }).then(function (user) {
29 | return done(null, user)
30 | }).catch(done)
31 | }
32 | ))
33 |
34 | exports.passport = passport
35 |
36 | /**
37 | * TODO
38 | */
39 | exports.indexRoute = function (req, res) {
40 | return res.sendFile('index.html', {
41 | root: `${__dirname}/../../client/public`
42 | })
43 | }
44 |
45 | /**
46 | * TODO
47 | */
48 | exports.queryRewrite = function (req, res, next) {
49 | try {
50 | req.query.jsdataOptions || (req.query.jsdataOptions = {})
51 | if (req.query.with) {
52 | req.query.jsdataOptions.with = req.query.with
53 | req.query.with = undefined
54 | }
55 | if (req.query.where) {
56 | req.query.where = JSON.parse(req.query.where)
57 | }
58 | if (req.query.orderBy || req.query.sort) {
59 | const orderBy = req.query.orderBy || req.query.sort
60 | if (orderBy.length) {
61 | req.query.orderBy = orderBy.map(function (clause) {
62 | if (typeof clause === 'string') {
63 | return JSON.parse(clause)
64 | }
65 | return clause
66 | })
67 | req.query.sort = undefined
68 | }
69 | }
70 | next()
71 | } catch (err) {
72 | next(err)
73 | }
74 | }
75 |
76 | /**
77 | * TODO
78 | */
79 | exports.errorHandler = function (err, req, res, next) {
80 | let responder
81 | if (err && req) {
82 | if (res && next) {
83 | // Normally you would be using some logging library
84 | console.log(err)
85 | }
86 | }
87 | if (typeof req.send === 'function') {
88 | responder = req
89 | } else if (typeof res.send === 'function') {
90 | responder = res
91 | }
92 | if (err instanceof Error) {
93 | responder.status(500).send(err.message)
94 | } else if (typeof err === 'number') {
95 | responder.status(err)
96 | } else if (typeof err === 'object') {
97 | responder.status(400).send(err)
98 | } else {
99 | responder.status(500)
100 | }
101 | responder.end()
102 | }
103 |
--------------------------------------------------------------------------------
/server/src/store.js:
--------------------------------------------------------------------------------
1 | 'use strict'
2 |
3 | // Container is mostly recommended for use in Node.js
4 | const Container = require('js-data').Container
5 | const Schema = require('js-data').Schema
6 | const nconf = require('nconf')
7 | const schemas = require('../../_shared/schemas')(Schema)
8 | const relations = require('../../_shared/relations')
9 | const adapterName = nconf.get('ADAPTER')
10 |
11 | const adapter = exports.adapter = require('./adapters')(adapterName).adapter
12 | const store = exports.store = new Container({
13 | mapperDefaults: {
14 | beforeCreate (props) {
15 | props.created_at = new Date()
16 | props.updated_at = new Date()
17 | },
18 | beforeUpdate (props) {
19 | props.updated_at = new Date()
20 | }
21 | }
22 | })
23 |
24 | store.registerAdapter(adapterName, adapter, { default: true })
25 |
26 | // The Comment Resource
27 | store.defineMapper('user', {
28 | // Our table names use plural form
29 | table: 'users',
30 | schema: schemas.user,
31 | relations: relations.user
32 | })
33 |
34 | // The Post Resource
35 | store.defineMapper('post', {
36 | // Our table names use plural form
37 | table: 'posts',
38 | schema: schemas.post,
39 | relations: relations.post
40 | })
41 |
42 | // The Comment Resource
43 | store.defineMapper('comment', {
44 | // Our table names use plural form
45 | table: 'comments',
46 | schema: schemas.comment,
47 | relations: relations.comment
48 | })
49 |
--------------------------------------------------------------------------------
/server/src/utils.js:
--------------------------------------------------------------------------------
1 | 'use strict'
2 |
3 | const Promise = require('bluebird')
4 |
5 | /**
6 | * This little generator simply saves us a lot of boilerplate code.
7 | *
8 | * @param {Function} method Method to wrap and make safe.
9 | * @return {Function} Wrapped method.
10 | */
11 | exports.makeSafe = function (method) {
12 | return function (req, res, next) {
13 | return Promise.try(function () {
14 | return method(req, res, next)
15 | }).catch(next)
16 | }
17 | }
18 |
--------------------------------------------------------------------------------