teamplay 0.0.1

package/react/wrapIntoSuspense.js

@@ -0,0 +1,63 @@
+import { useMemo, forwardRef as _forwardRef, memo, createElement as el, Suspense } from 'react'
+import { createCaches } from '@startupjs/cache'
+import { __increment, __decrement } from '@startupjs/debug'
+import { pipeComponentMeta, pipeComponentDisplayName, ComponentMetaContext, useUnmount } from './helpers.js'
+
+export default function wrapIntoSuspense (
+  ObservedComponent
+) {
+  const { forwardRef, suspenseProps } = ObservedComponent.__observerOptions
+  if (!(suspenseProps && suspenseProps.fallback)) {
+    throw Error(
+      '[observer()] You must pass at least ' +
+      'a fallback parameter to suspenseProps'
+    )
+  }
+
+  let SuspenseWrapper = (props, ref) => {
+    const cache = useMemo(() => {
+      __increment('ObserverWrapper.cache')
+      return createCaches(['styles', 'model'])
+    }, [])
+    // TODO: using useState instead of useMemo will keep this intact during Fast Refresh
+    //       Research if we can change it to use it.
+    // const [componentMeta] = React.useState({
+    //   componentId: $root.id(),
+    //   createdAt: Date.now(),
+    //   cache
+    // })
+    const componentMeta = useMemo(function () {
+      return {
+        // componentId: $root.id(), // TODO: implement creating a unique component guid here (if it's needed anymore)
+        createdAt: Date.now(),
+        cache
+      }
+    }, [])
+
+    useUnmount(() => {
+      __decrement('ObserverWrapper.cache')
+      cache.clear()
+    })
+
+    if (forwardRef) props = { ...props, ref }
+
+    return (
+      el(ComponentMetaContext.Provider, { value: componentMeta },
+        el(Suspense, suspenseProps,
+          el(ObservedComponent, props)
+        )
+      )
+    )
+  }
+
+  // pipe only displayName because forwardRef render function
+  // do not support propTypes or defaultProps
+  pipeComponentDisplayName(ObservedComponent, SuspenseWrapper, 'StartupjsObserverWrapper')
+
+  if (forwardRef) SuspenseWrapper = _forwardRef(SuspenseWrapper)
+  SuspenseWrapper = memo(SuspenseWrapper)
+
+  pipeComponentMeta(ObservedComponent, SuspenseWrapper)
+
+  return SuspenseWrapper
+}

package/schema/GUID_PATTERN.js

@@ -0,0 +1 @@
+export default '^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$'

package/schema/associations.js

@@ -0,0 +1,51 @@
+import GUID_PATTERN from './GUID_PATTERN.js'
+
+export function belongsTo (collectionName) {
+  return {
+    type: 'string',
+    pattern: GUID_PATTERN,
+    $association: {
+      type: 'belongsTo',
+      collection: collectionName
+    }
+  }
+}
+
+export function hasMany (collectionName) {
+  return {
+    type: 'array',
+    items: {
+      type: 'string',
+      pattern: GUID_PATTERN
+    },
+    $association: {
+      type: 'hasMany',
+      collection: collectionName
+    }
+  }
+}
+
+export function hasManyFlags (collectionName) {
+  return {
+    type: 'object',
+    patternProperties: {
+      [GUID_PATTERN]: { type: 'boolean' }
+    },
+    additionalProperties: false,
+    $association: {
+      type: 'hasManyFlags',
+      collection: collectionName
+    }
+  }
+}
+
+export function hasOne (collectionName) {
+  return {
+    type: 'string',
+    pattern: GUID_PATTERN,
+    $association: {
+      type: 'hasOne',
+      collection: collectionName
+    }
+  }
+}

package/schema/pickFormFields.js

@@ -0,0 +1,104 @@
+/**
+ * Pick properties from json-schema to be used in a form.
+ * Supports simplified schema (just the properties object) and full schema.
+ * Performs extra transformations like auto-generating `label`.
+ * `createdAt`, `updatedAt`, `id`, `_id` fields are excluded by default.
+ * @param {Object} schema
+ * @param {Object|Array} options - exclude or include fields. If array, it's the same as passing { include: [...] }
+ * @param {Array} options.include - list of fields to pick (default: all)
+ * @param {Array} options.exclude - list of fields to exclude (default: none)
+ * @param {Boolean} options.freeze - whether to deep freeze the result (default: true)
+ */
+export default function pickFormFields (schema, options) {
+  try {
+    let include, exclude, freeze
+    if (Array.isArray(options)) {
+      include = options
+    } else {
+      ;({ include, exclude, freeze = true } = options || {})
+    }
+    exclude ??= []
+    if (!schema) throw Error('pickFormFields: schema is required')
+    schema = JSON.parse(JSON.stringify(schema))
+    if (schema.type === 'object') {
+      schema = schema.properties
+    }
+    for (const key in schema) {
+      if (shouldIncludeField(key, schema[key], { include, exclude })) {
+        const field = schema[key]
+        if (!field.label) field.label = camelCaseToLabel(key)
+      } else {
+        delete schema[key]
+      }
+    }
+    if (freeze) return new Proxy(schema, deepFreezeHandler)
+    return schema
+  } catch (err) {
+    throw Error(`
+      pickFormFields: ${err.message}
+      schema:\n${JSON.stringify(schema, null, 2)}
+    `)
+  }
+}
+
+// Proxy handlers to deep freeze schema to prevent accidental mutations.
+// For this, when we .get() a property, we also return the same recursive Proxy handler if it's an object.
+const deepFreezeHandler = {
+  get (target, prop) {
+    const value = target[prop]
+    if (typeof value === 'object' && value !== null) {
+      return new Proxy(value, deepFreezeHandler)
+    }
+    return value
+  },
+  set () {
+    throw Error(ERRORS.schemaIsFrozen)
+  }
+}
+
+function shouldIncludeField (key, field, { include, exclude = [] } = {}) {
+  if (!field) throw Error(`field "${key}" does not have a schema definition`)
+  if (include?.includes(key)) return true
+  if (exclude.includes(key)) return false
+  // if field has 'input' specified then it's an explicit indicator that it can be used in forms,
+  // so the default exclusion rules don't apply
+  if (!field.input) {
+    // exclude some meta fields by default
+    if (DEFAULT_EXCLUDE_FORM_FIELDS.includes(key)) return false
+    // exclude foreign keys by default
+    // Foreign keys have a custom `$association` property set by belongsTo/hasMany/hasOne helpers
+    if (field.$association) return false
+  }
+  // if include array is not explicitly set, include all fields by default
+  if (!include) return true
+  return false
+}
+
+const DEFAULT_EXCLUDE_FORM_FIELDS = ['id', '_id', 'createdAt', 'updatedAt']
+
+// split into words, capitalize first word, make others lowercase
+function camelCaseToLabel (str) {
+  return str
+    .replace(/([A-Z])/g, ' $1')
+    .toLowerCase()
+    .replace(/^./, (s) => s.toUpperCase())
+}
+
+const ERRORS = {
+  schemaIsFrozen: `
+    Form fields are immutable.
+    If you want to change them, clone them with \`JSON.parse(JSON.stringify(FORM_FIELDS))\`.
+
+    If you want to do it inside react component, you can use this pattern for the most effective cloning:
+
+    \`\`\`
+        const $fields = useValue$(useMemo(() => JSON.parse(JSON.stringify(FORM_FIELDS)), []))
+    \`\`\`
+
+    and then pass $fields to the Form component like this:
+
+    \`\`\`
+        <Form $fields={$fields} $value={$value} />
+    \`\`\`
+  `
+}

package/server.js

@@ -0,0 +1,12 @@
+import createChannel from '@startupjs/channel/server'
+import { connection, setConnection, setFetchOnly } from './orm/connection.js'
+
+export { default as ShareDB } from 'sharedb'
+
+export default function initConnection (backend, options) {
+  if (!backend) throw Error('backend is required')
+  if (connection) throw Error('Connection already exists')
+  setConnection(backend.connect())
+  setFetchOnly(true)
+  return createChannel(backend, options)
+}

package/utils/uuid.cjs

@@ -0,0 +1,2 @@
+const { v4: uuid } = require('uuid')
+module.exports = uuid