@cero-base/cero 0.4.0

package/src/builder.js

@@ -0,0 +1,276 @@
+import { join } from 'path'
+import { promises as fs } from 'fs'
+
+import Hyperschema from 'hyperschema'
+import HyperdbBuilder from 'hyperdb/builder'
+import Hyperdispatch from 'hyperdispatch'
+import HRPCBuilder from 'hrpc'
+
+import { CeroError } from '@cero-base/core/errors'
+
+import {
+  BUILTINS,
+  LOCAL_BUILTINS,
+  hyperdbType,
+  builtinTypes,
+  builtinCollections,
+  builtinDispatches,
+  localBuiltinTypes,
+  localBuiltinCollections,
+  rpcTypes,
+  rpcCommands
+} from './lib/builtins.js'
+
+const NS = 'cero'
+
+/**
+ * @typedef {import('@cero-base/core/schema').Schema} Schema
+ * @typedef {import('@cero-base/core/schema').SchemaDefs} SchemaDefs
+ * @typedef {Schema | (SchemaDefs & { local?: SchemaDefs })} SchemaInput
+ *
+ * @typedef {object} BuildOpts
+ * @property {string} [ns]  Namespace prefix for emitted schema ids. Defaults to `'cero'`.
+ */
+
+/**
+ * Compile a cero schema into wire-level artifacts and write them to disk.
+ *
+ * Emits a `main/` tree (schema + hyperdb + dispatch + rpc), a `local/` tree
+ * for per-device data, one `handles/<name>/` tree per child handle type, and
+ * an `index.js` that re-exports a ready-to-use `spec` object.
+ *
+ * @param {string} specDir          Output directory.
+ * @param {SchemaInput} schema      Either a `schema(...)` wrapper or its raw defs object.
+ * @param {BuildOpts} [opts]
+ * @returns {Promise<void>}
+ */
+export async function build(specDir, schema, { ns = NS } = {}) {
+  const defs = /** @type {SchemaDefs & { local?: SchemaDefs }} */ (schema?.defs || schema)
+  if (!defs || typeof defs !== 'object') throw CeroError.REQUIRED('schema')
+
+  const main = compile(splitMain(defs), ns, BUILTINS)
+  const local = defs.local
+    ? compile(defs.local, ns, LOCAL_BUILTINS)
+    : compile({}, ns, LOCAL_BUILTINS)
+  const handles = {}
+  for (const [name, child] of Object.entries(splitHandles(defs))) {
+    handles[name] = compile(child, ns)
+  }
+
+  emitMain(join(specDir, 'main'), ns, main, { rpc: true })
+  emitLocal(join(specDir, 'local'), ns, local)
+  for (const [name, handle] of Object.entries(handles)) {
+    emitMain(join(specDir, 'handles', name), ns, handle, { rpc: false })
+  }
+
+  const meta = {
+    ...main.meta,
+    local: local.meta,
+    handles: Object.fromEntries(
+      Object.entries(handles).map(([n, h]) => [n, { ...h.meta, type: n }])
+    )
+  }
+
+  // Hang a `type: <name>` marker on each handle ref in main so the runtime knows which type to open.
+  for (const [name] of Object.entries(handles)) {
+    if (meta.refs[name]) meta.refs[name] = { kind: 'handle', type: name, schema: `@${ns}/handle` }
+  }
+
+  await fs.writeFile(join(specDir, 'index.js'), wireModule(meta, Object.keys(handles)), 'utf-8')
+}
+
+function splitMain(defs) {
+  const out = {}
+  for (const [k, v] of Object.entries(defs)) {
+    if (k === 'local') continue
+    if (isPlainHandle(v)) {
+      out[k] = { kind: 'handle', type: k }
+      continue
+    }
+    out[k] = v
+  }
+  return out
+}
+
+function splitHandles(defs) {
+  const out = {}
+  for (const [k, v] of Object.entries(defs)) {
+    if (k === 'local') continue
+    if (isPlainHandle(v)) out[k] = v
+  }
+  return out
+}
+
+function isPlainHandle(v) {
+  return v && typeof v === 'object' && !v.kind && !v.prim
+}
+
+function compile(root, ns, builtins = BUILTINS) {
+  const ctx = { types: [], collections: [], dispatches: [], meta: { ns, refs: {} }, ns }
+
+  for (const b of builtins) {
+    ctx.meta.refs[b.name] = {
+      kind: b.kind || 'collection',
+      path: [b.name],
+      builtin: true,
+      verb: b.verb,
+      schema: `@${ns}/${b.type}`
+    }
+  }
+
+  for (const [name, node] of Object.entries(root)) {
+    if (node.kind === 'handle') {
+      ctx.meta.refs[name] = { kind: 'handle', type: node.type || name, schema: `@${ns}/handle` }
+      continue
+    }
+    register(name, node, ctx)
+  }
+
+  return {
+    types: ctx.types,
+    collections: ctx.collections,
+    dispatches: ctx.dispatches,
+    meta: ctx.meta
+  }
+}
+
+function register(name, node, ctx) {
+  const fqn = `@${ctx.ns}/${name}`
+  if (node.kind === 'action') {
+    ctx.types.push({ name, compact: false, fields: fieldsFor(node.fields) })
+    ctx.dispatches.push({ name, requestType: fqn })
+    ctx.meta.refs[name] = { kind: 'action', path: [name], schema: fqn }
+    return
+  }
+  if (node.kind === 'single') {
+    ctx.types.push({ name, compact: false, fields: fieldsFor(node.fields) })
+    ctx.collections.push({ name, schema: fqn, key: [] })
+    ctx.dispatches.push({ name: `set-${name}`, requestType: fqn })
+    ctx.meta.refs[name] = { kind: 'single', path: [name], schema: fqn }
+    return
+  }
+  if (node.kind === 'collection') {
+    ctx.types.push({
+      name,
+      compact: false,
+      fields: [
+        { name: 'id', type: 'string', required: true },
+        { name: 'memberId', type: 'string', required: false },
+        { name: 'index', type: 'uint', required: false },
+        { name: 'createdAt', type: 'int', required: false },
+        { name: 'updatedAt', type: 'int', required: false },
+        ...fieldsFor(node.fields)
+      ]
+    })
+    ctx.collections.push({ name, schema: fqn, key: ['id'] })
+    ctx.dispatches.push({ name: `add-${name}`, requestType: fqn })
+    ctx.dispatches.push({ name: `set-${name}`, requestType: fqn })
+    ctx.dispatches.push({ name: `del-${name}`, requestType: `@${ctx.ns}/del-by-id` })
+    ctx.meta.refs[name] = { kind: 'collection', path: [name], schema: fqn }
+  }
+}
+
+function fieldsFor(fields) {
+  return Object.entries(fields).map(([name, marker]) => ({
+    name,
+    type: hyperdbType(marker.prim),
+    required: false
+  }))
+}
+
+function emitMain(dir, ns, { types, collections, dispatches }, { rpc }) {
+  const schemaDir = join(dir, 'schema')
+  const dbDir = join(dir, 'db')
+  const dispatchDir = join(dir, 'dispatch')
+  const rpcDir = join(dir, 'rpc')
+
+  const s = Hyperschema.from(schemaDir)
+  const sns = s.namespace(ns)
+  for (const desc of builtinTypes()) sns.register(desc)
+  for (const desc of types) sns.register(desc)
+  if (rpc) for (const desc of rpcTypes()) sns.register(desc)
+  Hyperschema.toDisk(s, schemaDir, { esm: true })
+
+  const db = HyperdbBuilder.from(schemaDir, dbDir)
+  const dns = db.namespace(ns)
+  for (const desc of builtinCollections(ns)) dns.collections.register(desc)
+  for (const desc of collections) dns.collections.register(desc)
+  HyperdbBuilder.toDisk(db, dbDir, { esm: true })
+
+  const d = Hyperdispatch.from(schemaDir, dispatchDir)
+  const xns = d.namespace(ns)
+  for (const desc of builtinDispatches(ns)) xns.register(desc)
+  for (const desc of dispatches) xns.register(desc)
+  Hyperdispatch.toDisk(d, dispatchDir, { esm: true })
+
+  if (rpc) {
+    const r = HRPCBuilder.from(schemaDir, rpcDir)
+    const rns = r.namespace(ns)
+    for (const desc of rpcCommands(ns)) rns.register(desc)
+    HRPCBuilder.toDisk(r, rpcDir, { esm: true })
+  }
+}
+
+function emitLocal(dir, ns, { types, collections }) {
+  const schemaDir = join(dir, 'schema')
+  const dbDir = join(dir, 'db')
+
+  const s = Hyperschema.from(schemaDir)
+  const sns = s.namespace(ns)
+  for (const desc of localBuiltinTypes()) sns.register(desc)
+  for (const desc of types) sns.register(desc)
+  Hyperschema.toDisk(s, schemaDir, { esm: true })
+
+  const db = HyperdbBuilder.from(schemaDir, dbDir)
+  const dns = db.namespace(ns)
+  for (const desc of localBuiltinCollections(ns)) dns.collections.register(desc)
+  for (const desc of collections) dns.collections.register(desc)
+  HyperdbBuilder.toDisk(db, dbDir, { esm: true })
+}
+
+const IMPORTS = {
+  database: (n) => `import ${n}Database from './handles/${n}/db/index.js'`,
+  dispatch: (n) => `import * as ${n}Dispatch from './handles/${n}/dispatch/index.js'`,
+  schema: (n) => `import * as ${n}Schema from './handles/${n}/schema/index.js'`
+}
+
+const cap = (s) => s[0].toUpperCase() + s.slice(1)
+
+function handleImports(names, kinds) {
+  return names.flatMap((n) => kinds.map((k) => IMPORTS[k](n))).join('\n')
+}
+
+function handleEntries(names, kinds) {
+  return names
+    .map((n) => {
+      const parts = kinds.map((k) => `${k}: ${n}${cap(k)}`).join(', ')
+      return `    ${n}: { ${parts}, meta: meta.handles.${n} }`
+    })
+    .join(',\n')
+}
+
+function wireModule(meta, names) {
+  const kinds = ['database', 'dispatch', 'schema']
+  return `// autogenerated by cero/build
+import database from './main/db/index.js'
+import * as dispatch from './main/dispatch/index.js'
+import * as schema from './main/schema/index.js'
+import rpc from './main/rpc/index.js'
+import localDatabase from './local/db/index.js'
+${handleImports(names, kinds)}
+
+export const meta = ${JSON.stringify(meta, null, 2)}
+
+export const spec = {
+  database,
+  dispatch,
+  schema,
+  rpc,
+  local: { database: localDatabase },
+  meta,
+  handles: {
+${handleEntries(names, kinds)}
+  }
+}
+`
+}

package/src/handle/CLAUDE.md

@@ -0,0 +1,3 @@
+<claude-mem-context>
+
+</claude-mem-context>