startupjs/server

> Express.js server with ShareDB integration and ORM

Usage

If you followed the startupjs project creation instructions and you are in a startupjs project then you don't need to write any code to start the server.

It's either embedded into Metro dev server for development, or for production it's embedded into yarn start-production command itself.

$3

When you run the server side part of startupjs manually through your own cli command, you have to import a startupjs Node.js loader for required preprocessing. Without it startupjs would not function correctly.

You can do it by either passing the --import option to node:

``sh
NODE_ENV=production node --experimental-detect-module --import=startupjs/nodeRegister ./server/index.js
`

Another way to import the loader is in the code itself. But in this case all subsequent imports in the same file must be async import() calls:

`js
import 'startupjs/nodeRegister'

const { default: startServer } = await import('startupjs/server')

await startServer()
`

$3

If you want to start the production server, you can do it the following way:

`js
import startServer from 'startupjs/server'

const { server, backend, session, channel, expressApp } = await startServer()

console.log('started')
`

$3

`js
import { createServer } from 'startupjs/server'

const { server, backend, session, channel, expressApp } = await createServer()

// if you want to start it:
server.listen(() => console.log('started'))
`

$3

`js
import { createMiddleware } from 'startupjs/server'

const { middleware, backend, session, channel } = await createMiddleware()

// do something with the middleware
`

$3

This is useful for cron or worker microservices where you just want to work with the database and don't need any http server running.

`js
import { createBackend } from 'startupjs/server'

const backend = createBackend()

function doSomething () {
const model = backend.createModel()
// do things with model and then close it (IMPORTANT!) to prevent memory leaks
model.close()
}

doSomething()
`

Security: Access Control

This allows you to control create, read, update, and delete database operation for every collection in ORM model by
exporting access from your model files.

By default all operations are denied.

If you want to allow operation, return true from the access checking function:

`js
// only owner of the document can update it
update: ({ doc, session }) => doc.userId === session.userId
`

If you want to allow an operation for everyone, you can just set true for it:

`js
// anyone can read the document
read: true
`

$3

1. Set accessControl: true in startupjs.config.js -> features:

`js
// startupjs.config.js
export default {
features: {
enableServer: true,
accessControl: true
}
}
`

2. Call accessControl function from startupjs and export result as access from the model file for a collection.

Important: You can only add access control to collection files, NOT document files. For example games.js, but not games.[id].js.

`js
// in model/users.js file
import { accessControl } from 'startupjs'
export const access = accessControl({
// only admins can create a new user
create: async ({ newDoc, docId, session, collection, type }) => session.isAdmin,
// everyone can read other users info (it's public)
read: async ({ doc, docId, session, collection, type }) => true,
// only user itself can update their data. Except of the admin who can update anyone's data.
update: async ({ doc, newDoc, docId, session, ops, collection, type }) => {
return session.userId === docId || session.isAdmin
},
// only admins can delete users
delete: async ({ doc, docId, session, collection, type }) => session.isAdmin
})
`

Security: Validate documents using JSON Schema

This allows you to force your MongoDB collections to always follow a specific json-schema definition.

If someone tries to write into an invalid field, that operation is going to be automatically denied and rolled back on the client.

This is especially useful during the development process to clearly define the shape of your data as well as reuse it to draw forms in the UI.

In the client code the same exact schema can be passed to