@cero-base/cero 1.18.2 → 2.0.0

package/src/build/builtins.js

@@ -1,174 +0,0 @@
-// Build wiring for the builtin schemas (schemas.js): turns the grouped field
-// maps into the type / collection / dispatch / command descriptors the builder
-// registers. Every cero schema includes these; app refs are added on top.
-import { CeroError } from '@cero-base/core/errors'
-import { COUNTERS, EPOCHS, DB_TYPE } from '../lib/constants.js'
-import * as schemas from './schemas.js'
-
-// Builtin collections by scope — ref name → { type, kind? }. kind defaults to
-// 'collection' (id-keyed); 'single' has no key. Dispatches are derived for
-// main; counters is internal (a collection with no add/set/del).
-export const refs = {
-  main: {
-    members: { type: 'member' },
-    devices: { type: 'device' },
-    invites: { type: 'invite' },
-    handles: { type: 'handle' },
-    files: { type: 'file' }
-  },
-  local: {
-    master: { type: 'master', kind: 'single' },
-    keypair: { type: 'keypair', kind: 'single' },
-    'handle-keypairs': { type: 'handle-keypair' },
-    environment: { type: 'environment', kind: 'single' }
-  }
-}
-
-export function getHyperdbType(prim) {
-  return DB_TYPE[prim] || 'string'
-}
-
-const at = (ns, n) => `@${ns}/${n}`
-const keyOf = (def) => (def.kind === 'single' ? [] : ['id'])
-
-const fields = (map) =>
-  Object.entries(map).map(([name, m]) => ({
-    name,
-    type: getHyperdbType(m.prim),
-    required: m.required === true
-  }))
-
-// Merge app `t.extend` fields into a builtin's base fields — base can't be redeclared.
-const merge = (type, base, extra) => {
-  if (!extra) return base
-  for (const k in extra) {
-    if (k in base) {
-      throw CeroError.INVALID(`'${k}' is a base field of '${type}' and cannot be redeclared`)
-    }
-  }
-  return { ...base, ...extra }
-}
-
-const descriptors = (group, extend = {}) =>
-  Object.entries(group).map(([name, base]) => ({
-    name,
-    compact: false,
-    fields: fields(merge(name, base, extend[name]))
-  }))
-
-// meta.refs entries for a scope's builtins.
-export function builtinRefs(ns, scope) {
-  return Object.fromEntries(
-    Object.entries(refs[scope]).map(([name, def]) => [
-      name,
-      {
-        kind: def.kind || 'collection',
-        path: [name],
-        builtin: true,
-        ...(scope === 'main' && { verb: def.type }),
-        schema: at(ns, def.type)
-      }
-    ])
-  )
-}
-
-// hyperschema type descriptors. scope is 'main' | 'local' | 'rpc'; `extend`
-// merges app `t.extend` fields into the matching type.
-export function builtinTypes(scope, extend) {
-  return descriptors(schemas[scope], extend)
-}
-export function rpcTypes() {
-  return descriptors(schemas.rpc)
-}
-
-// hyperdb collection descriptors for a scope.
-export function builtinCollections(ns, scope) {
-  const out = Object.entries(refs[scope]).map(([name, def]) => ({
-    name,
-    schema: at(ns, def.type),
-    key: keyOf(def)
-  }))
-  if (scope === 'main') {
-    out.push({ name: COUNTERS, schema: at(ns, 'counter'), key: ['name'] })
-    out.push({ name: EPOCHS, schema: at(ns, 'epoch'), key: ['epoch'] })
-  }
-  return out
-}
-
-// hyperdispatch descriptors (main scope only).
-export function builtinDispatches(ns) {
-  return [
-    { name: 'add-writer', requestType: at(ns, 'writer') },
-    { name: 'del-writer', requestType: at(ns, 'writer') },
-    { name: 'claim-writer', requestType: at(ns, 'claim') },
-    ...Object.values(refs.main).flatMap(({ type }) => [
-      { name: `add-${type}`, requestType: at(ns, type) },
-      { name: `set-${type}`, requestType: at(ns, type) },
-      { name: `del-${type}`, requestType: at(ns, 'del-by-id') }
-    ])
-  ]
-}
-
-// Registered AFTER the app's own dispatches (see build/index.js): hyperdispatch
-// numbers routes positionally and persists them, so a spec built before
-// rotation must see rotate-key appended at the end — inserting it into the
-// builtin group would collide with the app's persisted route ids on an
-// incremental rebuild.
-export function rotateDispatch(ns) {
-  return { name: 'rotate-key', requestType: at(ns, 'epoch') }
-}
-
-export function rpcCommands(ns) {
-  const ref = (n) => at(ns, n)
-  return [
-    { name: 'init', request: { name: ref('req-empty') }, response: { name: ref('res-identity') } },
-    {
-      name: 'restore',
-      request: { name: ref('req-restore') },
-      response: { name: ref('res-identity') }
-    },
-    { name: 'seed', request: { name: ref('req-empty') }, response: { name: ref('res-seed') } },
-    { name: 'add-row', request: { name: ref('req-row') }, response: { name: ref('res-data') } },
-    {
-      name: 'add-file',
-      request: { name: ref('req-add-file') },
-      response: { name: ref('res-data') }
-    },
-    {
-      name: 'add-handle',
-      request: { name: ref('req-row') },
-      response: { name: ref('res-handle') }
-    },
-    { name: 'set', request: { name: ref('req-row') }, response: { name: ref('res-data') } },
-    { name: 'get', request: { name: ref('req-query') }, response: { name: ref('res-rows') } },
-    { name: 'get-one', request: { name: ref('req-id') }, response: { name: ref('res-data') } },
-    { name: 'del', request: { name: ref('req-id') }, response: { name: ref('res-ok') } },
-    { name: 'count', request: { name: ref('req-query') }, response: { name: ref('res-count') } },
-    {
-      name: 'watch',
-      request: { name: ref('req-query') },
-      response: { name: ref('res-rows'), stream: true }
-    },
-    { name: 'call', request: { name: ref('req-call') }, response: { name: ref('res-data') } },
-    { name: 'invite', request: { name: ref('req-invite') }, response: { name: ref('res-invite') } },
-    { name: 'revoke', request: { name: ref('req-revoke') }, response: { name: ref('res-ok') } },
-    { name: 'join', request: { name: ref('req-join') }, response: { name: ref('res-handle') } },
-    {
-      name: 'open-handle',
-      request: { name: ref('req-open') },
-      response: { name: ref('res-handle') }
-    },
-    {
-      name: 'close-handle',
-      request: { name: ref('req-handle') },
-      response: { name: ref('res-ok') }
-    },
-    { name: 'leave', request: { name: ref('req-handle') }, response: { name: ref('res-ok') } },
-    {
-      name: 'changes',
-      request: { name: ref('req-query') },
-      response: { name: ref('res-changes'), stream: true }
-    },
-    { name: 'rotate', request: { name: ref('req-handle') }, response: { name: ref('res-epoch') } }
-  ]
-}

package/src/lib/internal.js

@@ -1,9 +0,0 @@
-// Process-wide registry for extensions registered via `cero.use()`.
-// `build()` folds in each extension's schema; `cero()` runs each setup.
-// The bundled extensions are on by default — `cero.use(profileSync({...}))`
-// replaces a default by name, `{ extensions: false }` (on build and cero)
-// leaves them out entirely.
-import { profileSync } from '../extensions/profile-sync.js'
-import { handleSync } from '../extensions/handle-sync.js'
-
-export const internal = { extensions: [profileSync(), handleSync()] }

package/src/lib/utils.js

@@ -1,67 +0,0 @@
-import { CeroError } from '@cero-base/core/errors'
-
-/**
- * @typedef {'collection' | 'single' | 'action' | 'handle'} RefKind
- * @typedef {{ kind?: string, schema?: string }} RefInfo
- *   Shape of the entries in `meta.refs` — describes a single ref name.
- *   `kind` is one of {@link RefKind}, kept as `string` since it originates
- *   from a generated spec.
- */
-
-/**
- * Typed pointer to a single ref (table or handle slot) on a `Handle` or
- * `Local`. Operators (`put`/`get`/`open`/...) take a `Ref` as their first
- * argument and dispatch through the owning handle's store.
- */
-export class Ref {
-  /**
-   * @param {any} handle  Owner — a `Handle` (or `Local`) the ref lives on.
-   * @param {string} name  Ref name as declared in the schema.
-   * @param {string} kind  Ref kind: `'collection'`, `'single'`, `'action'`, or `'handle'`.
-   * @param {string | null} [schema]  Fully-qualified schema id, if any.
-   */
-  constructor(handle, name, kind, schema = null) {
-    this.handle = handle
-    this.name = name
-    this.kind = kind
-    this.schema = schema
-  }
-}
-
-/**
- * Attach a `Ref` property to `target` for every entry in `refs`. Used by
- * `Handle` and `Local` during `_open()` so callers can write
- * `handle.someRef` instead of looking refs up by name.
- *
- * @param {any} target
- * @param {Record<string, RefInfo>} refs
- */
-export function attachRefs(target, refs) {
-  for (const [name, info] of Object.entries(refs || {})) {
-    // Fail loud rather than silently overwrite a method/property (close, on,
-    // store, …) when a schema declares a ref named like a reserved member.
-    if (name in target) {
-      throw CeroError.INVALID(
-        `schema ref '${name}' collides with a reserved ${target.constructor?.name || 'handle'} member — rename it`
-      )
-    }
-    target[name] = new Ref(target, name, info.kind, info.schema)
-  }
-}
-
-/**
- * Run `cb` when `signal` aborts — or immediately if it already has. No-op
- * without a signal. The listener removes itself on fire. Returns a disposer that
- * detaches the listener early, so a manual unsubscribe doesn't leave it lingering
- * on a long-lived signal.
- *
- * @param {AbortSignal | undefined} signal
- * @param {() => void} cb
- * @returns {(() => void) | undefined}
- */
-export function onAbort(signal, cb) {
-  if (!signal) return
-  if (signal.aborted) return void cb()
-  signal.addEventListener('abort', cb, { once: true })
-  return () => signal.removeEventListener('abort', cb)
-}

package/types/build/builtins.d.ts

@@ -1,100 +0,0 @@
-export function getHyperdbType(prim: any): any;
-export function builtinRefs(ns: any, scope: any): {
-    [k: string]: {
-        schema: string;
-        verb: any;
-        kind: any;
-        path: string[];
-        builtin: boolean;
-    };
-};
-export function builtinTypes(scope: any, extend: any): {
-    name: string;
-    compact: boolean;
-    fields: {
-        name: string;
-        type: any;
-        required: boolean;
-    }[];
-}[];
-export function rpcTypes(): {
-    name: string;
-    compact: boolean;
-    fields: {
-        name: string;
-        type: any;
-        required: boolean;
-    }[];
-}[];
-export function builtinCollections(ns: any, scope: any): {
-    name: string;
-    schema: string;
-    key: string[];
-}[];
-export function builtinDispatches(ns: any): {
-    name: string;
-    requestType: string;
-}[];
-export function rotateDispatch(ns: any): {
-    name: string;
-    requestType: string;
-};
-export function rpcCommands(ns: any): ({
-    name: string;
-    request: {
-        name: string;
-    };
-    response: {
-        name: string;
-        stream?: undefined;
-    };
-} | {
-    name: string;
-    request: {
-        name: string;
-    };
-    response: {
-        name: string;
-        stream: boolean;
-    };
-})[];
-export namespace refs {
-    namespace main {
-        namespace members {
-            let type: string;
-        }
-        namespace devices {
-            let type_1: string;
-            export { type_1 as type };
-        }
-        namespace invites {
-            let type_2: string;
-            export { type_2 as type };
-        }
-        namespace handles {
-            let type_3: string;
-            export { type_3 as type };
-        }
-        namespace files {
-            let type_4: string;
-            export { type_4 as type };
-        }
-    }
-    let local: {
-        master: {
-            type: string;
-            kind: string;
-        };
-        keypair: {
-            type: string;
-            kind: string;
-        };
-        'handle-keypairs': {
-            type: string;
-        };
-        environment: {
-            type: string;
-            kind: string;
-        };
-    };
-}

package/types/lib/internal.d.ts

@@ -1,24 +0,0 @@
-export namespace internal {
-    let extensions: ({
-        name: string;
-        bundled: boolean;
-        schema: {
-            profile: import("@cero-base/core").TypeDef;
-            members: {
-                kind: "extend";
-                fields: Record<string, import("@cero-base/core").Prim>;
-            };
-        };
-        setup(me: any): void;
-    } | {
-        name: string;
-        bundled: boolean;
-        schema: {
-            handles: {
-                kind: "extend";
-                fields: Record<string, import("@cero-base/core").Prim>;
-            };
-        };
-        setup(me: any): void;
-    })[];
-}

package/types/lib/utils.d.ts

@@ -1,55 +0,0 @@
-/**
- * Attach a `Ref` property to `target` for every entry in `refs`. Used by
- * `Handle` and `Local` during `_open()` so callers can write
- * `handle.someRef` instead of looking refs up by name.
- *
- * @param {any} target
- * @param {Record<string, RefInfo>} refs
- */
-export function attachRefs(target: any, refs: Record<string, RefInfo>): void;
-/**
- * Run `cb` when `signal` aborts — or immediately if it already has. No-op
- * without a signal. The listener removes itself on fire. Returns a disposer that
- * detaches the listener early, so a manual unsubscribe doesn't leave it lingering
- * on a long-lived signal.
- *
- * @param {AbortSignal | undefined} signal
- * @param {() => void} cb
- * @returns {(() => void) | undefined}
- */
-export function onAbort(signal: AbortSignal | undefined, cb: () => void): (() => void) | undefined;
-/**
- * @typedef {'collection' | 'single' | 'action' | 'handle'} RefKind
- * @typedef {{ kind?: string, schema?: string }} RefInfo
- *   Shape of the entries in `meta.refs` — describes a single ref name.
- *   `kind` is one of {@link RefKind}, kept as `string` since it originates
- *   from a generated spec.
- */
-/**
- * Typed pointer to a single ref (table or handle slot) on a `Handle` or
- * `Local`. Operators (`put`/`get`/`open`/...) take a `Ref` as their first
- * argument and dispatch through the owning handle's store.
- */
-export class Ref {
-    /**
-     * @param {any} handle  Owner — a `Handle` (or `Local`) the ref lives on.
-     * @param {string} name  Ref name as declared in the schema.
-     * @param {string} kind  Ref kind: `'collection'`, `'single'`, `'action'`, or `'handle'`.
-     * @param {string | null} [schema]  Fully-qualified schema id, if any.
-     */
-    constructor(handle: any, name: string, kind: string, schema?: string | null);
-    handle: any;
-    name: string;
-    kind: string;
-    schema: string;
-}
-export type RefKind = "collection" | "single" | "action" | "handle";
-/**
- * Shape of the entries in `meta.refs` — describes a single ref name.
- * `kind` is one of {@link RefKind}, kept as `string` since it originates
- * from a generated spec.
- */
-export type RefInfo = {
-    kind?: string;
-    schema?: string;
-};