@zeronsh/orbit 0.1.0

package/dist/chunk-QR3NSGHJ.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../drizzle/src/cli/type-resolution.ts","../drizzle/src/cli/generate.ts"],"names":["path2"],"mappings":"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","file":"chunk-QR3NSGHJ.js","sourcesContent":["// Resolve each column's *TypeScript* type with the compiler (via ts-morph), so a\n// Drizzle `.$type<...>()` and enum unions survive into the generated schema —\n// information that does not exist at runtime. For column `c` of table exported as\n// `user`, we resolve `InferSelectModel<typeof user>['c']` (the canonical Drizzle\n// row-type accessor), strip nullability (Orbit models it with `optional()`), and\n// keep the result as the column's custom type. Named types it references (e.g.\n// `PostMeta`, or `import(\"…/country\").Country`) are rewritten to bare names and\n// collected as `import type` lines for the generated file.\n\nimport * as path from 'node:path';\n\nexport interface ResolveColumn {\n  readonly jsKey: string;\n  readonly dbName: string;\n  readonly baseType: 'string' | 'number' | 'boolean' | 'json';\n}\n\nexport interface ResolveTable {\n  /** The export name of the table in the schema module (e.g. `user`). */\n  readonly exportName: string;\n  /** The Orbit/database table name. */\n  readonly tableName: string;\n  readonly columns: readonly ResolveColumn[];\n}\n\nexport interface ResolveOptions {\n  /** Absolute path to the user's Drizzle schema module. */\n  readonly schemaModulePath: string;\n  /** Absolute path of the file being generated (for relative import specifiers). */\n  readonly outputFilePath: string;\n  /** Optional tsconfig for module resolution. */\n  readonly tsConfigFilePath?: string;\n  /** Append `.js` to emitted relative import specifiers (Node16/NodeNext). */\n  readonly jsExtension?: boolean;\n}\n\nexport interface ResolvedTypes {\n  /** `tableName → dbColumnName → TS type expression`. */\n  readonly customTypes: Record<string, Record<string, string>>;\n  /** `import type` lines the generated file needs for named custom types. */\n  readonly typeImports: { module: string; names: string[] }[];\n}\n\nconst TRIVIAL = new Set(['string', 'number', 'boolean', 'unknown', 'any', 'never', '{}', 'object']);\nconst NS = '__orbitDrizzleSchema';\n\nfunction stripNull(text: string): string {\n  return text\n    .replace(/\\s*\\|\\s*null\\b/g, '')\n    .replace(/\\bnull\\s*\\|\\s*/g, '')\n    .replace(/\\s*\\|\\s*undefined\\b/g, '')\n    .trim();\n}\n\n/** Module specifier from `from` (the generated file) to `to` (a TS module). */\nfunction relSpecifier(fromFile: string, toModule: string, jsExtension: boolean): string {\n  let rel = path.relative(path.dirname(fromFile), toModule).replace(/\\\\/g, '/');\n  if (!rel.startsWith('.')) rel = `./${rel}`;\n  rel = rel.replace(/\\.tsx?$/, '');\n  return jsExtension ? `${rel}.js` : rel;\n}\n\nexport async function resolveCustomTypes(tables: readonly ResolveTable[], options: ResolveOptions): Promise<ResolvedTypes> {\n  // ts-morph is an optional peer dependency; import lazily so the runtime path\n  // never needs it.\n  const { Project, ts } = await import('ts-morph');\n\n  const project = options.tsConfigFilePath\n    ? new Project({ tsConfigFilePath: options.tsConfigFilePath, skipAddingFilesFromTsConfig: true })\n    : new Project({\n        compilerOptions: { strict: true, moduleResolution: ts.ModuleResolutionKind.Bundler, target: ts.ScriptTarget.ES2022 },\n        skipAddingFilesFromTsConfig: true,\n      });\n\n  project.addSourceFileAtPath(options.schemaModulePath);\n\n  const schemaDir = path.dirname(options.schemaModulePath);\n  const schemaSpecifier = `./${path.basename(options.schemaModulePath).replace(/\\.tsx?$/, '')}`;\n\n  // One type alias per column, plus an index so we can map back.\n  const aliases: { name: string; tableName: string; dbName: string; baseType: ResolveColumn['baseType'] }[] = [];\n  let body = `import type { InferSelectModel } from 'drizzle-orm';\\nimport type * as ${NS} from ${JSON.stringify(schemaSpecifier)};\\n`;\n  let i = 0;\n  for (const t of tables) {\n    for (const c of t.columns) {\n      const name = `C_${i++}`;\n      body += `type ${name} = InferSelectModel<typeof ${NS}.${t.exportName}>[${JSON.stringify(c.jsKey)}];\\n`;\n      aliases.push({ name, tableName: t.tableName, dbName: c.dbName, baseType: c.baseType });\n    }\n  }\n\n  const probe = project.createSourceFile(path.join(schemaDir, '__orbit_drizzle_probe__.ts'), body, { overwrite: true });\n  const flags = ts.TypeFormatFlags.NoTruncation;\n\n  const customTypes: Record<string, Record<string, string>> = {};\n  // module specifier → set of imported names\n  const importsByModule = new Map<string, Set<string>>();\n  const addImport = (moduleSpecifier: string, name: string) => {\n    const set = importsByModule.get(moduleSpecifier) ?? new Set<string>();\n    set.add(name);\n    importsByModule.set(moduleSpecifier, set);\n  };\n\n  for (const a of aliases) {\n    const alias = probe.getTypeAliasOrThrow(a.name);\n    const fullType = alias.getType();\n    const constituents = fullType.isUnion() ? fullType.getUnionTypes() : [fullType];\n    const nonNull = constituents.filter((c) => !c.isNull() && !c.isUndefined());\n\n    // Keep a custom type only when it's a genuine *subtype* of the column's Orbit\n    // base type. Otherwise the base type is the right one (e.g. a `timestamp`\n    // maps to `number`, even though its Drizzle TS type is `Date`).\n    const compatible =\n      a.baseType === 'json'\n        ? true\n        : nonNull.length > 0 &&\n          nonNull.every((c) => {\n            if (a.baseType === 'string') return c.isString() || c.isStringLiteral() || c.isTemplateLiteral();\n            if (a.baseType === 'number') return c.isNumber() || c.isNumberLiteral();\n            return c.isBoolean() || c.isBooleanLiteral();\n          });\n    if (!compatible) continue;\n\n    let text = stripNull(fullType.getText(alias, flags));\n\n    // Rewrite `import(\"ABS\").Name` → `Name`, collecting an import from ABS.\n    text = text.replace(/import\\(\"([^\"]+)\"\\)\\.(\\w+)/g, (_m, abs: string, name: string) => {\n      const spec = relSpecifier(options.outputFilePath, abs, Boolean(options.jsExtension));\n      addImport(spec, name);\n      return name;\n    });\n\n    // Rewrite `__orbitDrizzleSchema.Name` → `Name`, importing from the schema module.\n    const schemaImportSpec = relSpecifier(options.outputFilePath, options.schemaModulePath, Boolean(options.jsExtension));\n    text = text.replace(new RegExp(`${NS}\\\\.(\\\\w+)`, 'g'), (_m, name: string) => {\n      addImport(schemaImportSpec, name);\n      return name;\n    });\n\n    // Drop trivial types; for json keep only meaningful object/array/named types.\n    if (TRIVIAL.has(text) || text === '') continue;\n    if (a.baseType === 'json' && (text === 'unknown' || text === 'any')) continue;\n\n    (customTypes[a.tableName] ??= {})[a.dbName] = text;\n  }\n\n  project.removeSourceFile(probe);\n\n  const typeImports = [...importsByModule.entries()].map(([module, names]) => ({ module, names: [...names].sort() }));\n  return { customTypes, typeImports };\n}\n","// The `orbit-drizzle generate` pipeline:\n//   import schema (runtime) → resolve custom types (ts-morph) → IR → emit → write.\n\nimport * as fs from 'node:fs/promises';\nimport * as path from 'node:path';\nimport { pathToFileURL } from 'node:url';\nimport { getTableColumns, getTableName, is, Table } from 'drizzle-orm';\nimport { emitSchema } from '../../../orm-core/src/index.ts';\nimport { drizzleToIR, type DrizzleAdapterConfig } from '../introspect.ts';\nimport { orbitTypeOf, type DrizzleColumnLike } from '../type-map.ts';\nimport { resolveCustomTypes, type ResolveTable } from './type-resolution.ts';\n\nexport interface GenerateOptions {\n  /** Path to the Drizzle schema module (a single `.ts` file exporting tables + relations). */\n  readonly schemaPath: string;\n  /** Output path. Default `./orbit-schema.gen.ts`. */\n  readonly outputPath?: string;\n  /** tsconfig for type resolution + module resolution. */\n  readonly tsConfigPath?: string;\n  /** Run Prettier over the output if available. */\n  readonly format?: boolean;\n  /** Append `.js` to relative imports (Node16/NodeNext ESM). */\n  readonly jsExtension?: boolean;\n  /** Module the Orbit schema helpers are imported from. Default `@orbit/client`. */\n  readonly importFrom?: string;\n  /** Exported schema const name. Default `schema`. */\n  readonly schemaName?: string;\n  /** Table/column selection (see {@link DrizzleAdapterConfig.tables}). */\n  readonly tables?: DrizzleAdapterConfig['tables'];\n  readonly debug?: boolean;\n}\n\nexport interface GenerateResult {\n  readonly outputPath: string;\n  readonly source: string;\n}\n\n/** Generate an Orbit schema source file from a Drizzle schema. */\nexport async function generate(options: GenerateOptions): Promise<GenerateResult> {\n  const schemaModulePath = path.resolve(options.schemaPath);\n  const outputPath = path.resolve(options.outputPath ?? './orbit-schema.gen.ts');\n\n  // 1. Load the schema module at runtime (tables + relations).\n  const moduleObj = (await import(pathToFileURL(schemaModulePath).href)) as Record<string, unknown>;\n\n  // 2. Collect per-table resolution metadata (export name, jsKey ↔ dbName).\n  const resolveTables: ResolveTable[] = [];\n  for (const [exportName, value] of Object.entries(moduleObj)) {\n    if (!is(value, Table)) continue;\n    const table = value as Table;\n    const tableName = getTableName(table);\n    if (options.tables && options.tables[tableName] === false) continue;\n    const cols = getTableColumns(table) as Record<string, DrizzleColumnLike & { name: string }>;\n    const columns = Object.entries(cols)\n      .map(([jsKey, col]) => {\n        const base = orbitTypeOf(col);\n        return base ? { jsKey, dbName: col.name, baseType: base } : null;\n      })\n      .filter((c): c is NonNullable<typeof c> => c !== null);\n    resolveTables.push({ exportName, tableName, columns });\n  }\n\n  // 3. Resolve custom `$type<>()` / enum types via the TypeScript compiler.\n  const { customTypes, typeImports } = await resolveCustomTypes(resolveTables, {\n    schemaModulePath,\n    outputFilePath: outputPath,\n    tsConfigFilePath: options.tsConfigPath,\n    jsExtension: options.jsExtension,\n  });\n\n  // 4. Build the IR with the resolved custom types folded in.\n  const ir = drizzleToIR(moduleObj, { customTypes, tables: options.tables, debug: options.debug });\n\n  // 5. Emit the Orbit schema source.\n  let source = emitSchema(ir, {\n    importFrom: options.importFrom ?? '@zeronsh/orbit/client',\n    schemaName: options.schemaName,\n    jsExtension: options.jsExtension,\n    typeImports,\n    header: [\n      `Generated by @orbit/drizzle from ${path.basename(schemaModulePath)} — do not edit by hand.`,\n      `Re-run \\`orbit-drizzle generate\\` to update.`,\n    ],\n  });\n\n  // 6. Optional Prettier.\n  if (options.format) source = await formatWithPrettier(source, outputPath);\n\n  await fs.writeFile(outputPath, source, 'utf8');\n  return { outputPath, source };\n}\n\nasync function formatWithPrettier(source: string, filepath: string): Promise<string> {\n  try {\n    const prettier = await import('prettier');\n    const config = (await prettier.resolveConfig(filepath)) ?? {};\n    return prettier.format(source, { ...config, parser: 'typescript' });\n  } catch {\n    console.warn('⚠️  orbit-drizzle: prettier not found — skipping formatting.');\n    return source;\n  }\n}\n"]}

package/dist/client.d.ts

@@ -0,0 +1,349 @@
+import { a as QueriesPatchOp, R as Row, b as RowPatchOp, C as CrudOp, M as Mutation, c as QueryHost, d as SchemaQueries, e as Query, A as AST, V as Value, O as OrderPart } from './query-BMK1cXAS.js';
+export { f as Condition, g as CorrelatedSubquery, h as Correlation, D as Direction, i as Downstream, P as PROTOCOL_VERSION, Q as QueryBuilder, j as SchemaQuery, k as SimpleOperator, S as Subscribable, T as TypedQuery, U as Upstream, l as ValuePosition, m as ViewLike, n as buildSchemaQueries, o as createBuilder, p as hashAST, q as hashString } from './query-BMK1cXAS.js';
+import { S as SchemaDef, R as RowOf, P as PkOf, A as AnySchema } from './schema-BNM6bks7.js';
+export { b as Cardinality, c as Column, d as Columns, C as Connection, a as Relationship, e as RelationshipsDef, f as RelationshipsMap, T as TableDef, V as ValueType, g as boolean, h as createSchema, j as json, n as number, o as optional, r as relationships, s as string, t as table } from './schema-BNM6bks7.js';
+import { a as MutatorDefs, b as QueryDefs, c as QueriesAPI, d as MutateAPI } from './custom-DzMQ-nY2.js';
+export { M as MutatorDef, Q as QueryDef, S as SchemaCRUD, T as TableCRUD, e as Transaction, f as collectOps, g as defineMutator, h as defineQuery } from './custom-DzMQ-nY2.js';
+
+/** The `put` variant of a desired-query patch op (always has a `hash`). */
+type QueryPut = Extract<QueriesPatchOp, {
+    op: 'put';
+}>;
+type TTL = number | `${number}${'s' | 'm' | 'h' | 'd'}` | 'forever' | 'none';
+/** Parse a TTL into milliseconds. `'forever'` → Infinity, `'none'`/0 → 0. */
+declare function parseTTL(ttl: TTL): number;
+type Scheduler = {
+    setTimeout: (fn: () => void, ms: number) => unknown;
+    clearTimeout: (handle: unknown) => void;
+};
+declare class QueryManager {
+    #private;
+    constructor(opts: {
+        onSubscribe: (put: QueryPut) => void;
+        onUnsubscribe: (hash: string) => void;
+        scheduler?: Scheduler;
+    });
+    /**
+     * Register interest in a query. Returns a release function (idempotent). The
+     * first registration subscribes upstream; identical queries dedupe to one.
+     */
+    add(hash: string, put: QueryPut, ttl?: TTL): () => void;
+    /** All currently-subscribed query `put` ops (for reconnect resume). */
+    active(): QueryPut[];
+    /** Number of live (subscribed, incl. within-TTL) queries — for tests/introspection. */
+    size(): number;
+}
+
+interface KV {
+    get(key: string): Promise<unknown>;
+    set(key: string, value: unknown): Promise<void>;
+    del(key: string): Promise<void>;
+    /** All `[key, value]` pairs whose key starts with `prefix`. */
+    entries(prefix: string): Promise<[string, unknown][]>;
+}
+/** In-memory KV — used by tests and as a no-IndexedDB fallback. */
+declare class MemoryKV implements KV {
+    #private;
+    get(key: string): Promise<unknown>;
+    set(key: string, value: unknown): Promise<void>;
+    del(key: string): Promise<void>;
+    entries(prefix: string): Promise<[string, unknown][]>;
+}
+/** IndexedDB-backed KV (browser). One object store, keyed by string. */
+declare class IDBKV implements KV {
+    #private;
+    constructor(name?: string);
+    get(key: string): Promise<unknown>;
+    set(key: string, value: unknown): Promise<void>;
+    del(key: string): Promise<void>;
+    entries(prefix: string): Promise<[string, unknown][]>;
+}
+
+/** A changed effective-row key, delivered to listeners so views update incrementally. */
+type ChangedKey = {
+    table: string;
+    key: string;
+};
+type Listener = (changed: ReadonlyArray<ChangedKey>) => void;
+declare class Store {
+    #private;
+    constructor(pkByTable?: Record<string, string[]>);
+    /** Primary-key columns for a table (for complete ordering in the evaluator). */
+    pkOf(table: string): string[];
+    /** Public pk-key for a row (used by the IVM-backed view to match changes). */
+    keyOf(table: string, row: Row): string;
+    /** The effective (synced + optimistic overlay) row for a pk key, or undefined. */
+    effectiveRow(table: string, key: string): Row | undefined;
+    apply(op: RowPatchOp): void;
+    applyAll(ops: RowPatchOp[]): void;
+    /** Queue an optimistic mutation's CRUD ops (applied on top of synced rows). */
+    addPending(id: number, ops: CrudOp[], mutation?: Mutation): void;
+    /** Drop pending mutations the server has confirmed (id <= confirmed). */
+    confirmThrough(id: number): void;
+    /** Originating messages of still-pending mutations (for resend after reload). */
+    pendingMutations(): Mutation[];
+    /** All rows for `table` with the optimistic overlay applied. */
+    effectiveRows(table: string): Row[];
+    subscribe(fn: Listener): () => void;
+    /** Load persisted rows + pending mutations from `kv` into memory. */
+    hydrate(kv: KV): Promise<void>;
+    /** Flush dirty rows + pending mutations to the KV (called debounced). */
+    flush(): Promise<void>;
+}
+
+type OrbitOptions<S extends SchemaDef = AnySchema> = {
+    server: string;
+    /** The schema — supplies end-to-end types for `query`/`mutate`. Optional. */
+    schema?: S;
+    /**
+     * Auth token (or async getter) sent to the server, which forwards it as a
+     * `Bearer` token to your push/query endpoints so they can authenticate.
+     */
+    auth?: string | (() => string | Promise<string>);
+    clientID?: string;
+    clientGroupID?: string;
+    /** Max reconnect backoff in ms (default 30s). Set 0 to disable reconnect. */
+    maxReconnectMs?: number;
+    /**
+     * How long a query stays subscribed after its last view is destroyed, before
+     * it's garbage-collected (a `del` is sent upstream). Default `'5m'`.
+     */
+    queryTTL?: TTL;
+    /**
+     * Persist synced rows + pending mutations to a `KV` (e.g. `new IDBKV()` in the
+     * browser) so data is available offline and survives reloads. Hydrated before
+     * the first connection.
+     */
+    persist?: KV;
+    /**
+     * Called when the server sends a terminal `error` message (e.g. auth/version
+     * failure). Without a handler the error is logged; the socket still reconnects
+     * with backoff, so handle fatal errors here (e.g. refresh auth or `close()`).
+     */
+    onError?: (e: {
+        kind: string;
+        message: string;
+    }) => void;
+};
+/** Per-table CRUD mutators, mirroring Zero's `z.mutate.<table>.<op>(row)`. */
+type TableMutator<T extends Row = Row, PK extends keyof T = keyof T> = {
+    insert(value: T): void;
+    upsert(value: T): void;
+    update(value: Pick<T, PK> & Partial<T>): void;
+    delete(value: Pick<T, PK>): void;
+};
+/** `orbit.query.<table>` — one schema-aware query per table (relationships by name). */
+type QueryAccess<S extends SchemaDef> = SchemaQueries<S>;
+/** `orbit.mutate.<table>` — one typed mutator per schema table. */
+type MutateAccess<S extends SchemaDef> = {
+    [K in keyof S['tables']]: TableMutator<RowOf<S['tables'][K]>, PkOf<S['tables'][K]>>;
+};
+/**
+ * A live view over a query's results, maintained **incrementally** by the IVM
+ * operator graph (see `ivm/`). The query is compiled to a pipeline of operators
+ * fed by the local store; each store change is pushed through as add/remove/edit
+ * and the materialized result is updated in place — not re-evaluated from
+ * scratch. `applyWhere` defaults to true (the client store is shared across
+ * subscriptions, so each view must filter to its own rows); pass false only when
+ * the caller guarantees the store already holds exactly this query's rows.
+ */
+declare class View<T extends Row = Row> {
+    #private;
+    data: T[];
+    constructor(store: Store, ast: AST, applyWhere?: boolean, onDestroy?: () => void);
+    subscribe(fn: () => void): () => void;
+    /** Stop reacting to store changes + release the query subscription (Zero's `view.destroy()`). */
+    destroy(): void;
+}
+declare class Orbit<S extends SchemaDef = AnySchema, MD extends MutatorDefs | undefined = undefined, QD extends QueryDefs | undefined = undefined> implements QueryHost {
+    #private;
+    clientID: string;
+    clientGroupID: string;
+    /** Per-table typed query builder (ad-hoc queries): `orbit.query.todo.where(...)`. */
+    readonly query: QueryAccess<S>;
+    /** Custom (named) queries from the `queries` option: `orbit.queries.allTodos()`. */
+    readonly queries: QD extends QueryDefs ? QueriesAPI<QD> : Record<string, never>;
+    /**
+     * Mutators. With a `mutators` option these are your custom mutators
+     * (`orbit.mutate.createTodo(args)`); otherwise per-table CRUD
+     * (`orbit.mutate.todo.insert(...)`).
+     */
+    readonly mutate: MD extends MutatorDefs ? MutateAPI<MD> : MutateAccess<S>;
+    constructor(opts: OrbitOptions<S> & {
+        mutators?: MD;
+        queries?: QD;
+    });
+    /** Build a raw (untyped) query against `table` — escape hatch. */
+    queryRaw(table: string): Query;
+    /** Subscribe to an ad-hoc query and return a live [`View`]. */
+    materialize(query: Query, ttl?: TTL): View;
+    /**
+     * Subscribe to a custom (named) query by name + args. The server's query
+     * endpoint resolves/authorizes it (with the connection's auth) into the actual
+     * query; the client uses the def's `ast` for local ordering/nesting/optimism.
+     *
+     * The local view DOES apply the def's `where` (applyWhere=true): the client
+     * store is shared across all subscriptions, so without it a filtered query like
+     * `issue({id})` would match every row another query synced (e.g. the issues
+     * list) and `.one()` would return the wrong row. This assumes the def's filter
+     * matches the server's resolution, which holds for ordinary parameterized
+     * queries; the store only ever holds server-authorized rows.
+     */
+    materializeNamed(name: string, args: unknown[], ast: AST, ttl?: TTL): View;
+    /** Apply a single CRUD op (mirrors `z.mutate.<table>.insert(...)`). */
+    mutateCrud(op: CrudOp): void;
+    /** Run a custom mutator by name (optimistically, then on the server). */
+    mutateCustom(name: string, args?: unknown): void;
+    close(): void;
+}
+
+/** A nested query result row: columns plus any `related` arrays under their alias. */
+type ResultRow = Record<string, unknown>;
+/** Total order with `null == null` (sorting semantics; mirrors `compare_values`). */
+declare function compareValues(a: Value, b: Value): number;
+/** Equality with `null != null` (join / `=` semantics; mirrors `values_equal`). */
+declare function valuesEqual(a: Value, b: Value): boolean;
+/**
+ * Evaluate `ast` against `getRows` (a function returning all current rows of a
+ * table). Returns nested result rows. Set `applyWhere: false` for server-resolved
+ * (named) queries whose `where` was already applied server-side.
+ */
+declare function evaluate(getRows: (table: string) => Row[], ast: AST, opts?: {
+    applyWhere?: boolean;
+    pkOf?: (table: string) => readonly string[];
+}): ResultRow[];
+/**
+ * Unwrap `.one()` relationships in a result tree to a single row (or `undefined`),
+ * recursively. The raw materialized shape keeps relationships as arrays (matching
+ * the server/IVM snapshot); this is the client-facing presentation transform.
+ */
+declare function unwrapSingular(rows: ResultRow[], ast: AST): ResultRow[];
+
+/** A row flowing through the pipeline plus its (eagerly materialized) children. */
+type Node = {
+    row: Row;
+    relationships: Record<string, Node[]>;
+};
+/** An incremental change propagated downstream through `push`. */
+type Change = {
+    type: 'add';
+    node: Node;
+} | {
+    type: 'remove';
+    node: Node;
+} | {
+    type: 'edit';
+    node: Node;
+    oldNode: Node;
+} | {
+    type: 'child';
+    node: Node;
+    relationshipName: string;
+    change: Change;
+};
+/** A change applied to a Source (bare rows — sources are leaves). */
+type SourceChange = {
+    type: 'add';
+    row: Row;
+} | {
+    type: 'remove';
+    row: Row;
+} | {
+    type: 'edit';
+    row: Row;
+    oldRow: Row;
+};
+/** Parameters for a fetch (pull). */
+type FetchRequest = {
+    constraint?: Record<string, Value>;
+    start?: {
+        row: Row;
+        basis: 'at' | 'after';
+    };
+    reverse?: boolean;
+};
+/** An operator: both the fetch (pull) and push sides, plus a downstream link. */
+interface Op {
+    fetch(req: FetchRequest): Node[];
+    push(change: Change): Change[];
+    output: Op | null;
+    setOutput(o: Op): void;
+}
+type Comparator = (a: Row, b: Row) => number;
+
+/** Supplies a source connection + primary key for each table in an AST. */
+interface SourceProvider {
+    pkOf(table: string): string[];
+    connect(table: string, order: OrderPart[]): Op;
+}
+declare function buildPipeline(ast: AST, provider: SourceProvider, partitionKey?: string[] | null): Op;
+
+declare class MaterializedView {
+    #private;
+    /** The current top-level result, in sort order. */
+    nodes: Node[];
+    constructor(top: Op, order: OrderPart[], pk: string[]);
+    /** The result as Zero's `{row, rels}` snapshot shape (hidden `zsubq_*` excluded). */
+    snapshot(): {
+        row: Row;
+        rels: Record<string, unknown>;
+    }[];
+}
+
+type Connection = {
+    output: Op | null;
+    order: OrderPart[];
+    cmp: Comparator;
+};
+declare class MemorySource {
+    #private;
+    readonly table: string;
+    readonly pk: string[];
+    constructor(table: string, pk: string[]);
+    insertInitial(row: Row): void;
+    rows(): Row[];
+    get(key: string): Row | undefined;
+    connect(order: OrderPart[]): SourceConnection;
+    fetchConn(req: FetchRequest, conn: Connection): Node[];
+    /** Apply a source change (commit-first) and propagate to all connections. */
+    push(change: SourceChange): void;
+}
+/** A set of MemorySources, one per table — a `SourceProvider` for the builder. */
+declare class MemorySourceProvider {
+    #private;
+    add(table: string, pk: string[], rows: Row[]): MemorySource;
+    source(table: string): MemorySource;
+    pkOf(table: string): string[];
+    connect(table: string, order: OrderPart[]): Op;
+    push(table: string, change: SourceChange): void;
+}
+/** One connection (consumer) of a MemorySource — an Input + push target. */
+declare class SourceConnection implements Op {
+    #private;
+    output: Op | null;
+    constructor(src: MemorySource, conn: Connection);
+    fetch(req: FetchRequest): Node[];
+    push(): Change[];
+    setOutput(o: Op): void;
+}
+
+declare class StoreProvider implements SourceProvider {
+    #private;
+    constructor(store: Store);
+    pkOf(table: string): string[];
+    connect(table: string, order: OrderPart[]): Op;
+    /** Push the change for one touched effective-row key into its table's source. */
+    applyChange(table: string, key: string): void;
+}
+/** Tables referenced anywhere in an AST (top + related + EXISTS subqueries). */
+declare function tablesOf(ast: AST, out?: Set<string>): Set<string>;
+/** Convert an IVM result node into a client row (nested arrays, singular unwrap). */
+declare function nodeToRow(node: {
+    row: Row;
+    relationships: Record<string, {
+        row: Row;
+        relationships: Record<string, unknown>;
+    }[]>;
+}, ast: AST): Record<string, unknown>;
+
+export { AST, AnySchema, type Change, type Comparator, CrudOp, type FetchRequest, IDBKV, type KV, MaterializedView, MemoryKV, MemorySource, MemorySourceProvider, MutateAPI, type MutateAccess, Mutation, MutatorDefs, type Node, type Op, Orbit, type OrbitOptions, OrderPart, PkOf, QueriesAPI, QueriesPatchOp, Query, type QueryAccess, QueryDefs, QueryHost, QueryManager, type QueryPut, type ResultRow, Row, RowOf, RowPatchOp, type Scheduler, SchemaDef, SchemaQueries, type SourceChange, SourceConnection, type SourceProvider, Store, StoreProvider, type TTL, type TableMutator, Value, View, buildPipeline, compareValues, evaluate, nodeToRow, parseTTL, tablesOf, unwrapSingular, valuesEqual };

package/dist/client.js

@@ -0,0 +1,3 @@
+export { IDBKV, MaterializedView, MemoryKV, MemorySource, MemorySourceProvider, Orbit, PROTOCOL_VERSION, Query, QueryManager, SchemaQuery, SourceConnection, Store, StoreProvider, TypedQuery, View, boolean, buildPipeline, buildSchemaQueries, collectOps, compareValues, createBuilder, createSchema, defineMutator, defineQuery, evaluate, hashAST, hashString, json, nodeToRow, number, optional, parseTTL, relationships, string, table, tablesOf, unwrapSingular, valuesEqual } from './chunk-N2NAKHMU.js';
+//# sourceMappingURL=client.js.map
+//# sourceMappingURL=client.js.map

package/dist/client.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"client.js"}

package/dist/custom-DzMQ-nY2.d.ts

@@ -0,0 +1,81 @@
+import { R as Row, Q as QueryBuilder, S as Subscribable, C as CrudOp } from './query-BMK1cXAS.js';
+import { S as SchemaDef, R as RowOf, P as PkOf } from './schema-BNM6bks7.js';
+
+/** Typed CRUD surface for one table inside a mutator transaction. */
+type TableCRUD<T extends Row, PK extends keyof T> = {
+    insert(value: T): void;
+    upsert(value: T): void;
+    update(value: Pick<T, PK> & Partial<T>): void;
+    delete(value: Pick<T, PK>): void;
+};
+/** `tx.mutate.<table>` for every table in the schema. */
+type SchemaCRUD<S extends SchemaDef> = {
+    [K in keyof S['tables']]: TableCRUD<RowOf<S['tables'][K]>, PkOf<S['tables'][K]>>;
+};
+/** The transaction passed to a mutator (mirrors Zero's `Transaction`). */
+type Transaction<S extends SchemaDef> = {
+    readonly location: 'client';
+    readonly mutate: SchemaCRUD<S>;
+};
+/**
+ * A mutator's body. Receives a transaction, the client-supplied `args`, and
+ * server-supplied `ctx` (the authenticated context — see the push endpoint). A
+ * def that doesn't need `ctx` can simply omit it from its destructure.
+ */
+type MutatorFn<S extends SchemaDef, Args, Ctx = unknown> = (c: {
+    tx: Transaction<S>;
+    args: Args;
+    ctx: Ctx;
+}) => void | Promise<void>;
+/**
+ * A mutator definition. Modeled as the function itself; its args type is inferred
+ * from the signature. (`any` in the `tx`/args positions keeps specific defs
+ * assignable to the `MutatorDefs` record.)
+ */
+type MutatorDef<Args = any> = (c: {
+    tx: Transaction<any>;
+    args: Args;
+    ctx: any;
+}) => void | Promise<void>;
+/** Define a custom mutator (mirrors Zero's `defineMutator`). */
+declare function defineMutator<S extends SchemaDef, Args, Ctx = unknown>(fn: MutatorFn<S, Args, Ctx>): MutatorDef<Args>;
+type MutatorDefs = Record<string, MutatorDef>;
+type ArgsOf<M> = M extends (c: {
+    tx: never;
+    args: infer A;
+    ctx: never;
+}) => unknown ? A : never;
+/** `orbit.mutate` derived from mutator defs — `tx` stripped, args kept. */
+type MutateAPI<MD extends MutatorDefs> = {
+    [K in keyof MD]: ArgsOf<MD[K]> extends void | undefined ? () => void : (args: ArgsOf<MD[K]>) => void;
+};
+type QueryFn<Args, Ctx, T extends Row> = (c: {
+    args: Args;
+    ctx: Ctx;
+}) => QueryBuilder<T>;
+/** A custom query definition (its args + result row types are inferred). */
+type QueryDef<Args = any, T extends Row = Row> = (c: {
+    args: Args;
+    ctx: any;
+}) => QueryBuilder<T>;
+/** Define a custom (named) query (mirrors Zero's `defineQuery`). */
+declare function defineQuery<T extends Row>(fn: () => QueryBuilder<T>): QueryDef<void, T>;
+declare function defineQuery<Args, Ctx, T extends Row>(fn: QueryFn<Args, Ctx, T>): QueryDef<Args, T>;
+type QueryDefs = Record<string, QueryDef>;
+type QArgsOf<Q> = Q extends (c: {
+    args: infer A;
+    ctx: never;
+}) => unknown ? A : never;
+type QRowOf<Q> = Q extends (c: never) => Subscribable<infer T> ? T : never;
+/** `orbit.queries` derived from query defs — call with args, get a `Subscribable`. */
+type QueriesAPI<QD extends QueryDefs> = {
+    [K in keyof QD]: QArgsOf<QD[K]> extends void | undefined ? () => Subscribable<QRowOf<QD[K]>> : (args: QArgsOf<QD[K]>) => Subscribable<QRowOf<QD[K]>>;
+};
+/**
+ * Run a mutator definition against a recording transaction and return the CRUD
+ * ops it produced. Use this on **your push endpoint** (the server forwarded the
+ * mutation to) to execute a mutator with context, then apply the ops to your DB.
+ */
+declare function collectOps<S extends SchemaDef>(schema: S, def: MutatorDef, args: unknown, ctx?: unknown): CrudOp[];
+
+export { type MutatorDef as M, type QueryDef as Q, type SchemaCRUD as S, type TableCRUD as T, type MutatorDefs as a, type QueryDefs as b, type QueriesAPI as c, type MutateAPI as d, type Transaction as e, collectOps as f, defineMutator as g, defineQuery as h };

package/dist/drizzle/cli/bin.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/drizzle/cli/bin.js

@@ -0,0 +1,51 @@
+#!/usr/bin/env node
+import { generate } from '../../chunk-QR3NSGHJ.js';
+import '../../chunk-2R6QPZNI.js';
+import '../../chunk-7CMFTRDQ.js';
+import '../../chunk-N2NAKHMU.js';
+import * as fs from 'fs';
+import * as path from 'path';
+import { pathToFileURL } from 'url';
+import { Command } from 'commander';
+
+var program = new Command();
+program.name("orbit-drizzle").description("Generate an Orbit schema from a Drizzle ORM schema.").argument("[schema]", "path to the Drizzle schema module (overrides config/--schema)").option("-s, --schema <path>", "path to the Drizzle schema module").option("-o, --output <path>", "output file (default ./orbit-schema.gen.ts)").option("-t, --tsconfig <path>", "tsconfig for type resolution").option("-c, --config <path>", "orbit-drizzle config file", "./orbit-drizzle.config.ts").option("-n, --schema-name <name>", "exported schema const name (default schema)").option("--import-from <module>", "module to import Orbit helpers from (default @orbit/client)").option("-f, --format", "format output with Prettier").option("-j, --js-extension", "append .js to relative imports (Node16/NodeNext ESM)").option("--debug", "verbose logging").action(async (schemaArg, opts) => {
+  try {
+    const fromFile = await loadConfig(opts.config);
+    const schemaPath = schemaArg ?? opts.schema ?? fromFile.schemaPath;
+    if (!schemaPath) {
+      console.error("\u274C orbit-drizzle: no schema given. Pass a path, use --schema, or set `schemaPath` in the config.");
+      process.exit(1);
+    }
+    const options = {
+      schemaPath,
+      outputPath: opts.output ?? fromFile.outputPath,
+      tsConfigPath: opts.tsconfig ?? fromFile.tsConfigPath,
+      schemaName: opts.schemaName ?? fromFile.schemaName,
+      importFrom: opts.importFrom ?? fromFile.importFrom,
+      format: opts.format ?? fromFile.format,
+      jsExtension: opts.jsExtension ?? fromFile.jsExtension,
+      tables: fromFile.tables,
+      debug: opts.debug ?? fromFile.debug
+    };
+    const { outputPath } = await generate(options);
+    console.log(`\u2705 orbit-drizzle: wrote ${path.relative(process.cwd(), outputPath)}`);
+  } catch (err) {
+    console.error(`\u274C orbit-drizzle: ${err.message}`);
+    if (opts.debug) console.error(err);
+    process.exit(1);
+  }
+});
+async function loadConfig(configPath) {
+  if (!configPath) return {};
+  const abs = path.resolve(configPath);
+  if (!fs.existsSync(abs)) return {};
+  const mod = await import(pathToFileURL(abs).href);
+  return mod.default ?? {};
+}
+program.parseAsync(process.argv).catch((err) => {
+  console.error(err);
+  process.exit(1);
+});
+//# sourceMappingURL=bin.js.map
+//# sourceMappingURL=bin.js.map

package/dist/drizzle/cli/bin.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../drizzle/src/cli/bin.ts"],"names":[],"mappings":"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","file":"bin.js","sourcesContent":["#!/usr/bin/env node\n// `orbit-drizzle` CLI. Generates an Orbit schema (`orbit-schema.gen.ts`) from a\n// Drizzle schema, preserving custom `$type<>()` and enum types via the TypeScript\n// compiler. The published bin is plain JS; in-repo, run the source via\n// `node --experimental-strip-types drizzle/src/cli/bin.ts`.\n\nimport * as fs from 'node:fs';\nimport * as path from 'node:path';\nimport { pathToFileURL } from 'node:url';\nimport { Command } from 'commander';\nimport { generate, type GenerateOptions } from './generate.ts';\n\nconst program = new Command();\n\nprogram\n  .name('orbit-drizzle')\n  .description('Generate an Orbit schema from a Drizzle ORM schema.')\n  .argument('[schema]', 'path to the Drizzle schema module (overrides config/--schema)')\n  .option('-s, --schema <path>', 'path to the Drizzle schema module')\n  .option('-o, --output <path>', 'output file (default ./orbit-schema.gen.ts)')\n  .option('-t, --tsconfig <path>', 'tsconfig for type resolution')\n  .option('-c, --config <path>', 'orbit-drizzle config file', './orbit-drizzle.config.ts')\n  .option('-n, --schema-name <name>', 'exported schema const name (default schema)')\n  .option('--import-from <module>', 'module to import Orbit helpers from (default @orbit/client)')\n  .option('-f, --format', 'format output with Prettier')\n  .option('-j, --js-extension', 'append .js to relative imports (Node16/NodeNext ESM)')\n  .option('--debug', 'verbose logging')\n  .action(async (schemaArg: string | undefined, opts: Record<string, unknown>) => {\n    try {\n      const fromFile = await loadConfig(opts.config as string);\n      const schemaPath = schemaArg ?? (opts.schema as string | undefined) ?? fromFile.schemaPath;\n      if (!schemaPath) {\n        console.error('❌ orbit-drizzle: no schema given. Pass a path, use --schema, or set `schemaPath` in the config.');\n        process.exit(1);\n      }\n      // CLI flags win over config; both fall back to generate()'s own defaults.\n      const options: GenerateOptions = {\n        schemaPath,\n        outputPath: (opts.output as string) ?? fromFile.outputPath,\n        tsConfigPath: (opts.tsconfig as string) ?? fromFile.tsConfigPath,\n        schemaName: (opts.schemaName as string) ?? fromFile.schemaName,\n        importFrom: (opts.importFrom as string) ?? fromFile.importFrom,\n        format: (opts.format as boolean | undefined) ?? fromFile.format,\n        jsExtension: (opts.jsExtension as boolean | undefined) ?? fromFile.jsExtension,\n        tables: fromFile.tables,\n        debug: (opts.debug as boolean | undefined) ?? fromFile.debug,\n      };\n      const { outputPath } = await generate(options);\n      console.log(`✅ orbit-drizzle: wrote ${path.relative(process.cwd(), outputPath)}`);\n    } catch (err) {\n      console.error(`❌ orbit-drizzle: ${(err as Error).message}`);\n      if (opts.debug) console.error(err);\n      process.exit(1);\n    }\n  });\n\nasync function loadConfig(configPath: string | undefined): Promise<Partial<GenerateOptions>> {\n  if (!configPath) return {};\n  const abs = path.resolve(configPath);\n  if (!fs.existsSync(abs)) return {};\n  const mod = (await import(pathToFileURL(abs).href)) as { default?: Partial<GenerateOptions> };\n  return mod.default ?? {};\n}\n\nprogram.parseAsync(process.argv).catch((err) => {\n  console.error(err);\n  process.exit(1);\n});\n"]}

package/dist/drizzle/cli.d.ts

@@ -0,0 +1,63 @@
+import { D as DrizzleAdapterConfig } from '../introspect-zNCdXfuc.js';
+import '../ir-DE_CZz0D.js';
+
+interface GenerateOptions {
+    /** Path to the Drizzle schema module (a single `.ts` file exporting tables + relations). */
+    readonly schemaPath: string;
+    /** Output path. Default `./orbit-schema.gen.ts`. */
+    readonly outputPath?: string;
+    /** tsconfig for type resolution + module resolution. */
+    readonly tsConfigPath?: string;
+    /** Run Prettier over the output if available. */
+    readonly format?: boolean;
+    /** Append `.js` to relative imports (Node16/NodeNext ESM). */
+    readonly jsExtension?: boolean;
+    /** Module the Orbit schema helpers are imported from. Default `@orbit/client`. */
+    readonly importFrom?: string;
+    /** Exported schema const name. Default `schema`. */
+    readonly schemaName?: string;
+    /** Table/column selection (see {@link DrizzleAdapterConfig.tables}). */
+    readonly tables?: DrizzleAdapterConfig['tables'];
+    readonly debug?: boolean;
+}
+interface GenerateResult {
+    readonly outputPath: string;
+    readonly source: string;
+}
+/** Generate an Orbit schema source file from a Drizzle schema. */
+declare function generate(options: GenerateOptions): Promise<GenerateResult>;
+
+interface ResolveColumn {
+    readonly jsKey: string;
+    readonly dbName: string;
+    readonly baseType: 'string' | 'number' | 'boolean' | 'json';
+}
+interface ResolveTable {
+    /** The export name of the table in the schema module (e.g. `user`). */
+    readonly exportName: string;
+    /** The Orbit/database table name. */
+    readonly tableName: string;
+    readonly columns: readonly ResolveColumn[];
+}
+interface ResolveOptions {
+    /** Absolute path to the user's Drizzle schema module. */
+    readonly schemaModulePath: string;
+    /** Absolute path of the file being generated (for relative import specifiers). */
+    readonly outputFilePath: string;
+    /** Optional tsconfig for module resolution. */
+    readonly tsConfigFilePath?: string;
+    /** Append `.js` to emitted relative import specifiers (Node16/NodeNext). */
+    readonly jsExtension?: boolean;
+}
+interface ResolvedTypes {
+    /** `tableName → dbColumnName → TS type expression`. */
+    readonly customTypes: Record<string, Record<string, string>>;
+    /** `import type` lines the generated file needs for named custom types. */
+    readonly typeImports: {
+        module: string;
+        names: string[];
+    }[];
+}
+declare function resolveCustomTypes(tables: readonly ResolveTable[], options: ResolveOptions): Promise<ResolvedTypes>;
+
+export { type GenerateOptions, type GenerateResult, type ResolveColumn, type ResolveTable, type ResolvedTypes, generate, resolveCustomTypes };

package/dist/drizzle/cli.js

@@ -0,0 +1,6 @@
+export { generate, resolveCustomTypes } from '../chunk-QR3NSGHJ.js';
+import '../chunk-2R6QPZNI.js';
+import '../chunk-7CMFTRDQ.js';
+import '../chunk-N2NAKHMU.js';
+//# sourceMappingURL=cli.js.map
+//# sourceMappingURL=cli.js.map

package/dist/drizzle/cli.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"cli.js"}

package/dist/drizzle.d.ts

@@ -0,0 +1,21 @@
+import { S as SchemaIR } from './ir-DE_CZz0D.js';
+import { O as OrmAdapter } from './adapter-C-AhY9cw.js';
+import { S as SchemaDef } from './schema-BNM6bks7.js';
+import { D as DrizzleAdapterConfig } from './introspect-zNCdXfuc.js';
+export { d as drizzleToIR } from './introspect-zNCdXfuc.js';
+
+/** The Drizzle → Orbit adapter (implements the ORM-agnostic `OrmAdapter`). */
+declare const drizzleAdapter: OrmAdapter<Record<string, unknown>, DrizzleAdapterConfig>;
+/**
+ * Build a live Orbit schema object from a Drizzle schema (runtime path).
+ *
+ * Returns a generic {@link SchemaDef}: correct at runtime and usable with
+ * `createBuilder` / `new Orbit({ schema })`. For a fully-typed schema that
+ * preserves `.$type<>()` custom types + enums, use the `orbit-drizzle` CLI (it
+ * resolves types with the TypeScript compiler — see the README).
+ */
+declare function defineOrbitSchema(schema: Record<string, unknown>, config?: DrizzleAdapterConfig): SchemaDef;
+/** Convert a Drizzle schema directly to the normalized IR (advanced / codegen). */
+declare function drizzleToSchemaIR(schema: Record<string, unknown>, config?: DrizzleAdapterConfig): SchemaIR;
+
+export { DrizzleAdapterConfig, defineOrbitSchema, drizzleAdapter, drizzleToSchemaIR };