@zeronsh/orbit 0.1.0

package/dist/drizzle.js

@@ -0,0 +1,20 @@
+import { drizzleToIR } from './chunk-2R6QPZNI.js';
+export { drizzleToIR } from './chunk-2R6QPZNI.js';
+import { buildOrbitSchema } from './chunk-7CMFTRDQ.js';
+import './chunk-N2NAKHMU.js';
+
+// drizzle/src/index.ts
+var drizzleAdapter = {
+  name: "drizzle",
+  toIR: drizzleToIR
+};
+function defineOrbitSchema(schema, config) {
+  return buildOrbitSchema(drizzleToIR(schema, config));
+}
+function drizzleToSchemaIR(schema, config) {
+  return drizzleToIR(schema, config);
+}
+
+export { defineOrbitSchema, drizzleAdapter, drizzleToSchemaIR };
+//# sourceMappingURL=drizzle.js.map
+//# sourceMappingURL=drizzle.js.map

package/dist/drizzle.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../drizzle/src/index.ts"],"names":[],"mappings":";;;;;;AAgBO,IAAM,cAAA,GAA4E;AAAA,EACvF,IAAA,EAAM,SAAA;AAAA,EACN,IAAA,EAAM;AACR;AAUO,SAAS,iBAAA,CAAkB,QAAiC,MAAA,EAA0C;AAC3G,EAAA,OAAO,gBAAA,CAAiB,WAAA,CAAY,MAAA,EAAQ,MAAM,CAAC,CAAA;AACrD;AAGO,SAAS,iBAAA,CAAkB,QAAiC,MAAA,EAAyC;AAC1G,EAAA,OAAO,WAAA,CAAY,QAAQ,MAAM,CAAA;AACnC","file":"drizzle.js","sourcesContent":["// @orbit/drizzle — generate an Orbit schema from a Drizzle ORM schema.\n//\n//   import * as schema from './db/schema';\n//   import { relations } from './db/relations';   // defineRelations(...) (optional)\n//   export const orbitSchema = defineOrbitSchema(schema, { relations });\n//\n// `defineOrbitSchema` builds the schema at runtime (fast, no codegen) but cannot\n// see `$type<>()` custom types — those are type-level only. For a fully-typed\n// schema (custom types + enums preserved), use the `orbit-drizzle generate` CLI,\n// which resolves types with the TypeScript compiler and emits an `*.gen.ts`.\n\nimport { buildOrbitSchema, type OrmAdapter, type SchemaIR } from '../../orm-core/src/index.ts';\nimport type { SchemaDef } from '../../client/src/index.ts';\nimport { drizzleToIR, type DrizzleAdapterConfig } from './introspect.ts';\n\n/** The Drizzle → Orbit adapter (implements the ORM-agnostic `OrmAdapter`). */\nexport const drizzleAdapter: OrmAdapter<Record<string, unknown>, DrizzleAdapterConfig> = {\n  name: 'drizzle',\n  toIR: drizzleToIR,\n};\n\n/**\n * Build a live Orbit schema object from a Drizzle schema (runtime path).\n *\n * Returns a generic {@link SchemaDef}: correct at runtime and usable with\n * `createBuilder` / `new Orbit({ schema })`. For a fully-typed schema that\n * preserves `.$type<>()` custom types + enums, use the `orbit-drizzle` CLI (it\n * resolves types with the TypeScript compiler — see the README).\n */\nexport function defineOrbitSchema(schema: Record<string, unknown>, config?: DrizzleAdapterConfig): SchemaDef {\n  return buildOrbitSchema(drizzleToIR(schema, config));\n}\n\n/** Convert a Drizzle schema directly to the normalized IR (advanced / codegen). */\nexport function drizzleToSchemaIR(schema: Record<string, unknown>, config?: DrizzleAdapterConfig): SchemaIR {\n  return drizzleToIR(schema, config);\n}\n\nexport { drizzleToIR };\nexport type { DrizzleAdapterConfig };\n"]}

package/dist/introspect-zNCdXfuc.d.ts

@@ -0,0 +1,31 @@
+import { S as SchemaIR } from './ir-DE_CZz0D.js';
+
+interface DrizzleAdapterConfig {
+    /**
+     * The Relations v2 object (`defineRelations(...)`), if it isn't one of the
+     * exports in the schema you passed. When omitted, it is auto-detected among the
+     * schema's exports; failing that, relationships are derived from foreign keys.
+     */
+    readonly relations?: unknown;
+    /**
+     * Per-table selection. Omit for "all tables, all columns". `false` excludes a
+     * table; an object selects columns (`{ id: true, secret: false }`). Primary-key
+     * columns are always included.
+     */
+    readonly tables?: Record<string, boolean | Record<string, boolean>>;
+    /**
+     * Custom TypeScript types per `table.column` (database names), supplied by the
+     * CLI's type resolver so `$type<>()` survives into codegen. Runtime callers
+     * can't read `$type` (it is type-level only), so this is normally CLI-only.
+     */
+    readonly customTypes?: Record<string, Record<string, string>>;
+    /** Synthesize relationships from foreign keys when no Relations object exists. Default true. */
+    readonly fkRelationships?: boolean;
+    /** Print what was skipped / inferred. */
+    readonly debug?: boolean;
+}
+type AnyRecord = Record<string, unknown>;
+/** Convert a Drizzle schema (`import * as schema`) into Orbit's {@link SchemaIR}. */
+declare function drizzleToIR(input: AnyRecord, config?: DrizzleAdapterConfig): SchemaIR;
+
+export { type DrizzleAdapterConfig as D, drizzleToIR as d };

package/dist/ir-DE_CZz0D.d.ts

@@ -0,0 +1,49 @@
+/** Orbit's column value types (mirrors `@orbit/client`'s `ValueType`, sans null). */
+type OrbitValueType = 'string' | 'number' | 'boolean' | 'json';
+interface IRColumn {
+    /** Orbit field name (the key used in queries/mutators). For Orbit this is the
+     *  database column name, since Orbit syncs raw Postgres rows. */
+    readonly name: string;
+    readonly type: OrbitValueType;
+    /** Nullable / has a database default the client can't supply. */
+    readonly optional: boolean;
+    /**
+     * A TypeScript *type expression* to specialize the column with (e.g.
+     * `` `${string}@${string}` ``, `'active' | 'inactive'`, `{ theme: string }`).
+     * Emitted as `string<...>()` / `json<...>()` etc. so a Drizzle `$type<>()` and
+     * enums survive into the generated schema. Type-level only; ignored at runtime.
+     */
+    readonly customType?: string;
+    /** Source ORM column type, for diagnostics only. */
+    readonly sourceType?: string;
+}
+interface IRTable {
+    /** Orbit table name (the database table name). */
+    readonly name: string;
+    readonly columns: readonly IRColumn[];
+    readonly primaryKey: readonly string[];
+}
+type Cardinality = 'one' | 'many';
+/** One hop of a relationship chain. */
+interface IRConnection {
+    readonly sourceField: readonly string[];
+    readonly destField: readonly string[];
+    /** Destination table name (a key into `tables`). */
+    readonly destSchema: string;
+    readonly cardinality: Cardinality;
+}
+interface IRRelationship {
+    /** Source table name. */
+    readonly table: string;
+    /** Relationship name (used as `q.related('<name>')`). */
+    readonly name: string;
+    /** 1 connection = direct (FK); 2 connections = many-to-many through a junction. */
+    readonly chain: readonly IRConnection[];
+}
+/** The complete normalized schema an adapter produces. */
+interface SchemaIR {
+    readonly tables: readonly IRTable[];
+    readonly relationships: readonly IRRelationship[];
+}
+
+export type { Cardinality as C, IRColumn as I, OrbitValueType as O, SchemaIR as S, IRConnection as a, IRRelationship as b, IRTable as c };

package/dist/orm-core.d.ts

@@ -0,0 +1,33 @@
+import { S as SchemaIR } from './ir-DE_CZz0D.js';
+export { C as Cardinality, I as IRColumn, a as IRConnection, b as IRRelationship, c as IRTable, O as OrbitValueType } from './ir-DE_CZz0D.js';
+export { O as OrmAdapter, d as defineAdapter } from './adapter-C-AhY9cw.js';
+import { S as SchemaDef } from './schema-BNM6bks7.js';
+
+/** Build a live Orbit schema object from the IR. */
+declare function buildOrbitSchema(ir: SchemaIR): SchemaDef;
+
+interface EmitOptions {
+    /** Module the Orbit schema helpers are imported from. Default `@orbit/client`. */
+    readonly importFrom?: string;
+    /** Append `.js` to the import (Node16/NodeNext ESM). Default false. */
+    readonly jsExtension?: boolean;
+    /** Exported schema const name. Default `schema`. */
+    readonly schemaName?: string;
+    /** Also emit `export type <Table> = RowOf<typeof <table>>` for each table. Default true. */
+    readonly rowTypes?: boolean;
+    /** Header comment lines (without leading `//`). */
+    readonly header?: readonly string[];
+    /**
+     * Extra `import type { ... } from '...'` lines to prepend — used to bring in the
+     * named TypeScript types referenced by resolved custom column types (e.g. a
+     * `jsonb().$type<PostMeta>()` resolves to `PostMeta`, imported from the schema).
+     */
+    readonly typeImports?: readonly {
+        readonly module: string;
+        readonly names: readonly string[];
+    }[];
+}
+/** Emit the full Orbit-schema TypeScript source for an IR. */
+declare function emitSchema(ir: SchemaIR, options?: EmitOptions): string;
+
+export { type EmitOptions, SchemaIR, buildOrbitSchema, emitSchema };

package/dist/orm-core.js

@@ -0,0 +1,4 @@
+export { buildOrbitSchema, defineAdapter, emitSchema } from './chunk-7CMFTRDQ.js';
+import './chunk-N2NAKHMU.js';
+//# sourceMappingURL=orm-core.js.map
+//# sourceMappingURL=orm-core.js.map

package/dist/orm-core.js.map

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

package/dist/query-BMK1cXAS.d.ts

@@ -0,0 +1,296 @@
+import { S as SchemaDef, a as Relationship, C as Connection, R as RowOf } from './schema-BNM6bks7.js';
+
+type Value = string | number | boolean | null;
+type Row = Record<string, Value | unknown>;
+type Direction = 'asc' | 'desc';
+type OrderPart = readonly [field: string, dir: Direction];
+type SimpleOperator = '=' | '!=' | 'IS' | 'IS NOT' | '<' | '>' | '<=' | '>=' | 'LIKE' | 'NOT LIKE' | 'ILIKE' | 'NOT ILIKE' | 'IN' | 'NOT IN';
+type ValuePosition = {
+    type: 'literal';
+    value: Value | readonly (string | number | boolean)[];
+} | {
+    type: 'column';
+    name: string;
+} | {
+    type: 'static';
+    anchor: 'authData' | 'preMutationRow';
+    field: string | string[];
+};
+type Condition = {
+    type: 'simple';
+    op: SimpleOperator;
+    left: ValuePosition;
+    right: ValuePosition;
+} | {
+    type: 'and';
+    conditions: Condition[];
+} | {
+    type: 'or';
+    conditions: Condition[];
+} | {
+    type: 'correlatedSubquery';
+    related: CorrelatedSubquery;
+    op: 'EXISTS' | 'NOT EXISTS';
+};
+type Correlation = {
+    parentField: string[];
+    childField: string[];
+};
+type CorrelatedSubquery = {
+    correlation: Correlation;
+    subquery: AST;
+    hidden?: boolean;
+    /** A `.one()` relationship — the client unwraps it to a single row (or undefined). */
+    singular?: boolean;
+};
+type AST = {
+    table: string;
+    alias?: string;
+    where?: Condition;
+    related?: CorrelatedSubquery[];
+    start?: {
+        row: Row;
+        exclusive: boolean;
+    };
+    limit?: number;
+    orderBy?: OrderPart[];
+};
+type RowPatchOp = {
+    op: 'put';
+    tableName: string;
+    value: Row;
+} | {
+    op: 'update';
+    tableName: string;
+    id: Row;
+    merge?: Row;
+    constrain?: string[];
+} | {
+    op: 'del';
+    tableName: string;
+    id: Row;
+} | {
+    op: 'clear';
+};
+type QueriesPatchOp = {
+    op: 'put';
+    hash: string;
+    ttl?: number;
+    ast?: AST;
+    name?: string;
+    args?: unknown[];
+} | {
+    op: 'del';
+    hash: string;
+} | {
+    op: 'clear';
+};
+type Downstream = ['connected', {
+    wsid: string;
+    timestamp?: number;
+}] | ['pokeStart', {
+    pokeID: string;
+    baseCookie: string | null;
+}] | [
+    'pokePart',
+    {
+        pokeID: string;
+        lastMutationIDChanges?: Record<string, number>;
+        gotQueriesPatch?: QueriesPatchOp[];
+        rowsPatch?: RowPatchOp[];
+    }
+] | ['pokeEnd', {
+    pokeID: string;
+    cookie: string;
+    cancel?: boolean;
+}] | ['pong', Record<string, never>] | ['error', {
+    kind: string;
+    message: string;
+}];
+type CrudOp = {
+    op: 'insert';
+    tableName: string;
+    primaryKey: string[];
+    value: Row;
+} | {
+    op: 'upsert';
+    tableName: string;
+    primaryKey: string[];
+    value: Row;
+} | {
+    op: 'update';
+    tableName: string;
+    primaryKey: string[];
+    value: Row;
+} | {
+    op: 'delete';
+    tableName: string;
+    primaryKey: string[];
+    value: Row;
+};
+type Mutation = {
+    type: 'crud';
+    id: number;
+    clientID: string;
+    name: '_zero_crud';
+    args: [{
+        ops: CrudOp[];
+    }];
+    timestamp: number;
+} | {
+    type: 'custom';
+    id: number;
+    clientID: string;
+    name: string;
+    args: unknown[];
+    timestamp: number;
+};
+type Upstream = ['initConnection', {
+    desiredQueriesPatch: QueriesPatchOp[];
+}] | ['changeDesiredQueries', {
+    desiredQueriesPatch: QueriesPatchOp[];
+}] | [
+    'push',
+    {
+        clientGroupID: string;
+        mutations: Mutation[];
+        pushVersion: number;
+        timestamp: number;
+        requestID: string;
+    }
+] | ['ping', Record<string, never>];
+declare const PROTOCOL_VERSION = 51;
+/** A simple stable string hash; the server treats the result as an opaque key. */
+declare function hashString(s: string): string;
+/** Stable hash of a query AST (matches the server's expectation of a string key). */
+declare function hashAST(ast: AST): string;
+
+declare class Query {
+    #private;
+    private constructor();
+    static from(table: string): Query;
+    where(field: string, op: SimpleOperator, value: Value | readonly (string | number | boolean)[]): Query;
+    whereExists(correlation: Correlation, subquery: Query, negated?: boolean): Query;
+    related(name: string, correlation: Correlation, subquery: Query): Query;
+    /** Append a fully-formed related entry (used for junction/`hidden` chains). */
+    addRelated(entry: CorrelatedSubquery): Query;
+    orderBy(field: string, dir: Direction): Query;
+    limit(n: number): Query;
+    one(): Query;
+    start(row: Row, exclusive?: boolean): Query;
+    /** Whether this query was marked `.one()` (singular). */
+    isSingular(): boolean;
+    ast(): AST;
+}
+/** A live view's read surface (avoids a circular import on `View`). */
+type ViewLike<T> = {
+    data: T[];
+    subscribe(fn: () => void): () => void;
+    /** Release the view + its query subscription (enables TTL/GC). */
+    destroy?(): void;
+};
+/** Anything `useQuery` can subscribe to (a typed query or a named query). */
+interface Subscribable<T> {
+    materialize(): ViewLike<T>;
+}
+/**
+ * A query builder result (a {@link TypedQuery} or {@link SchemaQuery}): subscribable
+ * and able to expose its AST. Custom query defs return one of these so the client
+ * can derive the AST and so the result row type can be inferred.
+ */
+interface QueryBuilder<T extends Row> extends Subscribable<T> {
+    ast(): AST;
+    query(): Query;
+}
+/** What a [`TypedQuery`] needs from the client to materialize itself. */
+interface QueryHost {
+    materialize(q: Query): ViewLike<Row>;
+}
+/**
+ * A query bound to a row type `T` (from the schema) and to its client, mirroring
+ * Zero's `z.query.<table>`. `where`/`orderBy` are checked against `T`'s columns,
+ * and the materialized result is typed `T[]`. The `One` type parameter tracks
+ * `.one()` so that when this query is used as a `related` child it types as a
+ * single row (`R | undefined`) instead of an array (`R[]`).
+ */
+declare class TypedQuery<T extends Row, One extends boolean = false> implements Subscribable<T> {
+    #private;
+    constructor(host: QueryHost | null, q: Query);
+    where<K extends keyof T & string>(field: K, op: SimpleOperator, value: T[K] | readonly NonNullable<T[K]>[]): TypedQuery<T, One>;
+    whereExists(correlation: Correlation, subquery: TypedQuery<Row, boolean> | Query, negated?: boolean): TypedQuery<T, One>;
+    /**
+     * Add a nested relationship. The result type gains `name`: a `R[]` array, or
+     * `R | undefined` if the child query was `.one()`.
+     */
+    related<Name extends string, R extends Row, ROne extends boolean>(name: Name, correlation: Correlation, subquery: TypedQuery<R, ROne>): TypedQuery<T & {
+        [K in Name]: ROne extends true ? R | undefined : R[];
+    }, One>;
+    orderBy<K extends keyof T & string>(field: K, dir: Direction): TypedQuery<T, One>;
+    limit(n: number): TypedQuery<T, One>;
+    one(): TypedQuery<T, true>;
+    start(row: Partial<T>, exclusive?: boolean): TypedQuery<T, One>;
+    /** The underlying untyped query (escape hatch). */
+    query(): Query;
+    ast(): AST;
+    /** Materialize into a live, typed view. */
+    materialize(): ViewLike<T>;
+}
+/** The last hop of a relationship chain (direct → only; junction → second). */
+type LastConn<R extends Relationship> = R extends readonly [Connection] ? R[0] : R extends readonly [Connection, infer Second extends Connection] ? Second : never;
+/** The relationships declared for table `N` of schema `S`. */
+type RelsOf<S extends SchemaDef, N extends string> = N extends keyof S['relationships'] ? S['relationships'][N] : Record<never, never>;
+/** Relationship names available on table `N`. */
+type RelNames<S extends SchemaDef, N extends string> = keyof RelsOf<S, N> & string;
+type RelChain<S extends SchemaDef, N extends string, Rel extends RelNames<S, N>> = RelsOf<S, N>[Rel] extends Relationship ? RelsOf<S, N>[Rel] : never;
+/** Destination table name of relationship `Rel` (last hop). */
+type DestName<S extends SchemaDef, N extends string, Rel extends RelNames<S, N>> = LastConn<RelChain<S, N, Rel>>['destSchema'] & string;
+/** `'one' | 'many'` of relationship `Rel` (last hop). */
+type DestCard<S extends SchemaDef, N extends string, Rel extends RelNames<S, N>> = LastConn<RelChain<S, N, Rel>>['cardinality'];
+/** The row type of a named table in the schema. */
+type TableRow<S extends SchemaDef, Name extends string> = Name extends keyof S['tables'] ? RowOf<S['tables'][Name]> : Row;
+/** Apply cardinality (relationship `many`/`one`, or a `.one()` child) to a row type. */
+type WithCard<Card extends Cardinality, R extends Row, ChildOne extends boolean> = (Card extends 'one' ? true : ChildOne) extends true ? R | undefined : R[];
+type Cardinality = 'one' | 'many';
+/** Result shape of `.related(rel)` with no callback (uses the schema row + cardinality). */
+type RelResult<S extends SchemaDef, N extends string, Rel extends RelNames<S, N>> = WithCard<DestCard<S, N, Rel>, TableRow<S, DestName<S, N, Rel>>, false>;
+declare class SchemaQuery<S extends SchemaDef, N extends string, T extends Row, One extends boolean = false> implements Subscribable<T> {
+    #private;
+    constructor(host: QueryHost | null, schema: S, table: N, q: Query);
+    where<K extends keyof T & string>(field: K, op: SimpleOperator, value: T[K] | readonly NonNullable<T[K]>[]): SchemaQuery<S, N, T, One>;
+    whereExists(correlation: Correlation, subquery: SchemaQuery<S, string, Row, boolean> | Query, negated?: boolean): SchemaQuery<S, N, T, One>;
+    orderBy<K extends keyof T & string>(field: K, dir: Direction): SchemaQuery<S, N, T, One>;
+    limit(n: number): SchemaQuery<S, N, T, One>;
+    one(): SchemaQuery<S, N, T, true>;
+    start(row: Partial<T>, exclusive?: boolean): SchemaQuery<S, N, T, One>;
+    /** Add a relationship by name (resolved from the schema), with an optional child query. */
+    related<Rel extends RelNames<S, N>>(name: Rel): SchemaQuery<S, N, T & {
+        [K in Rel]: RelResult<S, N, Rel>;
+    }, One>;
+    related<Rel extends RelNames<S, N>, CT extends Row, COne extends boolean>(name: Rel, cb: (q: SchemaQuery<S, DestName<S, N, Rel>, TableRow<S, DestName<S, N, Rel>>>) => SchemaQuery<S, string, CT, COne>): SchemaQuery<S, N, T & {
+        [K in Rel]: WithCard<DestCard<S, N, Rel>, CT, COne>;
+    }, One>;
+    /** Add a relationship with an explicit correlation (schema-less escape hatch). */
+    related<Name extends string, R extends Row, ROne extends boolean>(name: Name, correlation: Correlation, subquery: SchemaQuery<S, string, R, ROne> | TypedQuery<R, ROne> | Query): SchemaQuery<S, N, T & {
+        [K in Name]: ROne extends true ? R | undefined : R[];
+    }, One>;
+    isSingular(): boolean;
+    /** The underlying untyped query (escape hatch). */
+    query(): Query;
+    ast(): AST;
+    materialize(): ViewLike<T>;
+}
+/** Every table of a schema as a {@link SchemaQuery}, optionally bound to a host. */
+type SchemaQueries<S extends SchemaDef> = {
+    [K in keyof S['tables'] & string]: SchemaQuery<S, K, RowOf<S['tables'][K]>>;
+};
+/**
+ * Standalone, schema-aware query builders (mirrors Zero's `createBuilder`). Use
+ * inside query definitions: `builder.issue.where('id', '=', args.id).related('author')`.
+ * Relationships declared in the schema are available by name and fully typed. The
+ * returned queries are unbound (used to produce ASTs, not subscribed directly).
+ */
+declare function createBuilder<S extends SchemaDef>(schema: S): SchemaQueries<S>;
+/** Build the per-table {@link SchemaQuery} map, optionally bound to a host. */
+declare function buildSchemaQueries<S extends SchemaDef>(schema: S, host: QueryHost | null): SchemaQueries<S>;
+
+export { type AST as A, type CrudOp as C, type Direction as D, type Mutation as M, type OrderPart as O, PROTOCOL_VERSION as P, type QueryBuilder as Q, type Row as R, type Subscribable as S, TypedQuery as T, type Upstream as U, type Value as V, type QueriesPatchOp as a, type RowPatchOp as b, type QueryHost as c, type SchemaQueries as d, Query as e, type Condition as f, type CorrelatedSubquery as g, type Correlation as h, type Downstream as i, SchemaQuery as j, type SimpleOperator as k, type ValuePosition as l, type ViewLike as m, buildSchemaQueries as n, createBuilder as o, hashAST as p, hashString as q };

package/dist/react.d.ts

@@ -0,0 +1,16 @@
+import { R as Row, S as Subscribable } from './query-BMK1cXAS.js';
+import './schema-BNM6bks7.js';
+
+/**
+ * Subscribe to a query and re-render on change. Mirrors `useQuery` from
+ * `@rocicorp/zero/react`. Accepts a typed query (`orbit.query.todo`) or a named
+ * query (`orbit.queryNamed(...)`); the result is typed either way.
+ *
+ * ```tsx
+ * const todos = orbit.query.todo.orderBy('created', 'asc');
+ * const rows = useQuery(todos); // rows: Todo[]
+ * ```
+ */
+declare function useQuery<T extends Row>(query: Subscribable<T>): T[];
+
+export { useQuery };

package/dist/react.js

@@ -0,0 +1,27 @@
+import { useRef, useState, useEffect } from 'react';
+
+// react/src/index.ts
+function useQuery(query) {
+  const ref = useRef(null);
+  const [, force] = useState(0);
+  if (ref.current === null || ref.current.q !== query) {
+    ref.current = { q: query, view: query.materialize() };
+  }
+  useEffect(() => {
+    if (ref.current === null || ref.current.q !== query) {
+      ref.current = { q: query, view: query.materialize() };
+    }
+    const entry = ref.current;
+    const unsub = entry.view.subscribe(() => force((n) => n + 1));
+    return () => {
+      unsub();
+      entry.view.destroy?.();
+      if (ref.current === entry) ref.current = null;
+    };
+  }, [query]);
+  return ref.current.view.data;
+}
+
+export { useQuery };
+//# sourceMappingURL=react.js.map
+//# sourceMappingURL=react.js.map

package/dist/react.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../react/src/index.ts"],"names":[],"mappings":";;;AAeO,SAAS,SAAwB,KAAA,EAA6B;AAMnE,EAAA,MAAM,GAAA,GAAM,OAAyD,IAAI,CAAA;AACzE,EAAA,MAAM,GAAG,KAAK,CAAA,GAAI,SAAS,CAAC,CAAA;AAI5B,EAAA,IAAI,IAAI,OAAA,KAAY,IAAA,IAAQ,GAAA,CAAI,OAAA,CAAQ,MAAM,KAAA,EAAO;AACnD,IAAA,GAAA,CAAI,UAAU,EAAE,CAAA,EAAG,OAAO,IAAA,EAAM,KAAA,CAAM,aAAY,EAAE;AAAA,EACtD;AAEA,EAAA,SAAA,CAAU,MAAM;AAId,IAAA,IAAI,IAAI,OAAA,KAAY,IAAA,IAAQ,GAAA,CAAI,OAAA,CAAQ,MAAM,KAAA,EAAO;AACnD,MAAA,GAAA,CAAI,UAAU,EAAE,CAAA,EAAG,OAAO,IAAA,EAAM,KAAA,CAAM,aAAY,EAAE;AAAA,IACtD;AACA,IAAA,MAAM,QAAQ,GAAA,CAAI,OAAA;AAClB,IAAA,MAAM,KAAA,GAAQ,KAAA,CAAM,IAAA,CAAK,SAAA,CAAU,MAAM,MAAM,CAAC,CAAA,KAAM,CAAA,GAAI,CAAC,CAAC,CAAA;AAC5D,IAAA,OAAO,MAAM;AACX,MAAA,KAAA,EAAM;AACN,MAAA,KAAA,CAAM,KAAK,OAAA,IAAU;AAGrB,MAAA,IAAI,GAAA,CAAI,OAAA,KAAY,KAAA,EAAO,GAAA,CAAI,OAAA,GAAU,IAAA;AAAA,IAC3C,CAAA;AAAA,EACF,CAAA,EAAG,CAAC,KAAK,CAAC,CAAA;AAEV,EAAA,OAAO,GAAA,CAAI,QAAS,IAAA,CAAK,IAAA;AAC3B","file":"react.js","sourcesContent":["// React bindings for Orbit, mirroring Zero's `@rocicorp/zero/react` `useQuery`.\n\nimport { useEffect, useRef, useState } from 'react';\nimport type { Row, Subscribable, ViewLike } from '../../client/src/index.ts';\n\n/**\n * Subscribe to a query and re-render on change. Mirrors `useQuery` from\n * `@rocicorp/zero/react`. Accepts a typed query (`orbit.query.todo`) or a named\n * query (`orbit.queryNamed(...)`); the result is typed either way.\n *\n * ```tsx\n * const todos = orbit.query.todo.orderBy('created', 'asc');\n * const rows = useQuery(todos); // rows: Todo[]\n * ```\n */\nexport function useQuery<T extends Row>(query: Subscribable<T>): T[] {\n  // Track the live view together with the query it belongs to, so a *changed*\n  // query (e.g. a route param flipping `issue({id})` to a new id without\n  // remounting the component) re-materializes instead of showing the stale view.\n  // The caller is expected to keep `query` referentially stable across renders\n  // that don't change it (e.g. `useMemo`), as is conventional for query hooks.\n  const ref = useRef<{ q: Subscribable<T>; view: ViewLike<T> } | null>(null);\n  const [, force] = useState(0);\n\n  // Materialize synchronously on first render or when the query changes, so this\n  // render already reflects the current query.\n  if (ref.current === null || ref.current.q !== query) {\n    ref.current = { q: query, view: query.materialize() };\n  }\n\n  useEffect(() => {\n    // The view may have been released by a prior cleanup (React Strict Mode's\n    // double-invoke, or a query change between render and commit); ensure a live\n    // view for THIS query.\n    if (ref.current === null || ref.current.q !== query) {\n      ref.current = { q: query, view: query.materialize() };\n    }\n    const entry = ref.current;\n    const unsub = entry.view.subscribe(() => force((n) => n + 1));\n    return () => {\n      unsub();\n      entry.view.destroy?.(); // releases the query subscription → enables TTL/GC\n      // Only clear the shared ref if it still points at the view we just tore\n      // down — a query change already replaced it with the next view.\n      if (ref.current === entry) ref.current = null;\n    };\n  }, [query]);\n\n  return ref.current!.view.data;\n}\n"]}

package/dist/schema-BNM6bks7.d.ts

@@ -0,0 +1,108 @@
+type ValueType = 'string' | 'number' | 'boolean' | 'json' | 'null';
+/** A column definition. The TS type it produces is carried in the `_type` phantom. */
+type Column<T = unknown> = {
+    readonly type: ValueType;
+    readonly optional: boolean;
+    /** Phantom — never present at runtime; carries the column's TS type. */
+    readonly _type?: T;
+};
+declare const string: <T extends string = string>() => Column<T>;
+declare const number: <T extends number = number>() => Column<T>;
+declare const boolean: <T extends boolean = boolean>() => Column<T>;
+declare const json: <T = unknown>() => Column<T>;
+/** Mark a column nullable (its TS type gains `| null`). */
+declare const optional: <T>(c: Column<T>) => Column<T | null>;
+type Columns = Record<string, Column>;
+type TableDef<Name extends string = string, C extends Columns = Columns, PK extends keyof C & string = keyof C & string> = {
+    readonly name: Name;
+    readonly columns: C;
+    readonly primaryKey: readonly PK[];
+};
+/** `table('todo').columns({ ... }).primaryKey('id')` */
+declare function table<Name extends string>(name: Name): {
+    columns<C extends Columns>(columns: C): {
+        primaryKey<PK extends keyof C & string>(...primaryKey: PK[]): TableDef<Name, C, PK>;
+    };
+};
+type Cardinality = 'one' | 'many';
+/** One hop of a relationship: which fields correlate and to which table. */
+type Connection = {
+    readonly sourceField: readonly string[];
+    readonly destField: readonly string[];
+    /** Destination table *name*. */
+    readonly destSchema: string;
+    readonly cardinality: Cardinality;
+};
+/** A relationship = a 1- (direct) or 2- (junction) element connection chain. */
+type Relationship = readonly [Connection] | readonly [Connection, Connection];
+/** The relationships declared for one source table. */
+type RelationshipsDef<Name extends string = string, R extends Record<string, Relationship> = Record<string, Relationship>> = {
+    readonly name: Name;
+    readonly relationships: R;
+};
+/** A single hop's arguments, where `destSchema` is the destination *table def*. */
+type ConnectArg<Dest extends TableDef = TableDef> = {
+    readonly sourceField: readonly string[];
+    readonly destField: readonly string[];
+    readonly destSchema: Dest;
+};
+type Connector<Card extends Cardinality> = {
+    <Dest extends TableDef>(arg: ConnectArg<Dest>): readonly [Connection & {
+        destSchema: Dest['name'];
+        cardinality: Card;
+    }];
+    <Junction extends TableDef, Dest extends TableDef>(first: ConnectArg<Junction>, second: ConnectArg<Dest>): readonly [
+        Connection & {
+            destSchema: Junction['name'];
+            cardinality: Card;
+        },
+        Connection & {
+            destSchema: Dest['name'];
+            cardinality: Card;
+        }
+    ];
+};
+/**
+ * Declare the relationships for `table` (mirrors Zero's `relationships`). Pass a
+ * callback that builds named relationships with `one(...)` / `many(...)`:
+ *
+ * ```ts
+ * relationships(issue, ({ one, many }) => ({
+ *   author: one({ sourceField: ['authorId'], destField: ['id'], destSchema: user }),
+ *   comments: many({ sourceField: ['id'], destField: ['issueId'], destSchema: comment }),
+ *   labels: many(
+ *     { sourceField: ['id'],      destField: ['issueId'], destSchema: issueLabel },
+ *     { sourceField: ['labelId'], destField: ['id'],      destSchema: label },
+ *   ),
+ * }));
+ * ```
+ */
+declare function relationships<Name extends string, R extends Record<string, Relationship>>(table: TableDef<Name>, cb: (connectors: {
+    one: Connector<'one'>;
+    many: Connector<'many'>;
+}) => R): RelationshipsDef<Name, R>;
+/** Relationships keyed by source-table name (the shape stored on a schema). */
+type RelationshipsMap = Record<string, Record<string, Relationship>>;
+type SchemaDef<T extends Record<string, TableDef> = Record<string, TableDef>, R extends RelationshipsMap = RelationshipsMap> = {
+    readonly tables: T;
+    readonly relationships: R;
+};
+/** Combine table + relationship defs into a schema keyed by table name. */
+declare function createSchema<const T extends readonly TableDef[], const R extends readonly RelationshipsDef[] = []>(def: {
+    tables: T;
+    relationships?: R;
+}): SchemaDef<{
+    [K in T[number] as K['name']]: K;
+}, {
+    [K in R[number] as K['name']]: K['relationships'];
+}>;
+/** The row type of a table def (column name -> TS value type). */
+type RowOf<T extends TableDef> = {
+    [K in keyof T['columns']]: T['columns'][K] extends Column<infer V> ? V : never;
+};
+/** The primary-key column names of a table def. */
+type PkOf<T extends TableDef> = T['primaryKey'][number];
+/** A permissive schema, used when no schema is supplied (everything is loose). */
+type AnySchema = SchemaDef<Record<string, TableDef>>;
+
+export { type AnySchema as A, type Connection as C, type PkOf as P, type RowOf as R, type SchemaDef as S, type TableDef as T, type ValueType as V, type Relationship as a, type Cardinality as b, type Column as c, type Columns as d, type RelationshipsDef as e, type RelationshipsMap as f, boolean as g, createSchema as h, json as j, number as n, optional as o, relationships as r, string as s, table as t };

package/dist/server/pg.d.ts

@@ -0,0 +1,18 @@
+import pg from 'pg';
+import { DBConnection } from '../server.js';
+import '../query-BMK1cXAS.js';
+import '../schema-BNM6bks7.js';
+import '../custom-DzMQ-nY2.js';
+
+/**
+ * Wrap a node-postgres `Pool`/`Client` (or a connection string / config) as a
+ * `DBConnection` for `PushProcessor`.
+ *
+ * ```ts
+ * import { nodePg } from '@zeronsh/orbit/server/pg';
+ * const connection = nodePg(process.env.DATABASE_URL!);
+ * ```
+ */
+declare function nodePg(db: pg.Pool | pg.Client | pg.PoolConfig | string): DBConnection;
+
+export { nodePg };

package/dist/server/pg.js

@@ -0,0 +1,35 @@
+import pg from 'pg';
+
+// server/src/pg.ts
+function nodePg(db) {
+  const pool = typeof db === "string" ? new pg.Pool({ connectionString: db }) : db instanceof pg.Pool || db instanceof pg.Client ? db : new pg.Pool(db);
+  return {
+    async transaction(fn) {
+      const client = pool instanceof pg.Pool ? await pool.connect() : pool;
+      const tx = {
+        async query(sql, params) {
+          const res = await client.query(sql, params);
+          return res.rows;
+        }
+      };
+      try {
+        await client.query("BEGIN");
+        const result = await fn(tx);
+        await client.query("COMMIT");
+        return result;
+      } catch (e) {
+        try {
+          await client.query("ROLLBACK");
+        } catch {
+        }
+        throw e;
+      } finally {
+        if (pool instanceof pg.Pool) client.release();
+      }
+    }
+  };
+}
+
+export { nodePg };
+//# sourceMappingURL=pg.js.map
+//# sourceMappingURL=pg.js.map