@abloatai/ablo 0.35.0 → 0.37.0

package/dist/transaction/schema/openapi.js

@@ -1,340 +0,0 @@
-// Pulled from the endpoints module to keep this schema file free of the client's
-// error-handling and credential dependencies.
-import { ABLO_HOSTED_HTTP_BASE_URL } from '../auth/hostedEndpoints.js';
-// The commit body is DERIVED from the schema the server validates against —
-// one definition site, so the documented surface cannot drift from the
-// enforced one.
-import { z } from 'zod';
-import { commitRequestSchema, commitReceiptSchema } from '../wire/commit.js';
-import { claimRequestSchema, claimHeartbeatRequestSchema, listQuerySchema, claimStateSchema, claimAcquiredResponseSchema, claimQueuedResponseSchema, claimHeartbeatReplySchema, } from '../wire/claims.js';
-import { modelReadResponseSchema, modelListResponseSchema } from '../wire/modelResponses.js';
-import { ephemeralKeyRequestSchema, capabilityRequestSchema } from '../wire/auth.js';
-import { EphemeralKeyResponseSchema } from '../auth/schemas.js';
-function fieldSchema(f) {
-    switch (f.type) {
-        case 'number':
-            return { type: 'number' };
-        case 'boolean':
-            return { type: 'boolean' };
-        case 'date':
-            return { type: 'string', format: 'date-time' };
-        case 'enum':
-            return f.enumValues ? { type: 'string', enum: [...f.enumValues] } : { type: 'string' };
-        case 'json':
-            return { type: 'object', additionalProperties: true };
-        case 'string':
-        default:
-            return { type: 'string' };
-    }
-}
-const pascal = (s) => s.charAt(0).toUpperCase() + s.slice(1);
-const idParam = () => ({ name: 'id', in: 'path', required: true, schema: { type: 'string' } });
-const jsonBody = (schema) => ({
-    required: true,
-    content: { 'application/json': { schema } },
-});
-/** For routes where an empty body is meaningful — a bare claim, a plain beat. */
-const optionalJsonBody = (schema) => ({
-    required: false,
-    content: { 'application/json': { schema } },
-});
-const jsonResp = (description, schema) => ({
-    description,
-    content: { 'application/json': { schema } },
-});
-/**
- * Derive a JSON Schema from a wire schema.
- *
- * `io` is not optional by accident. A request is what the caller SENDS, so it
- * derives from the input type; a response is what the server RETURNS, so it
- * derives from the output type. Reversing them is silent — the document still
- * looks like a working spec — which is why the direction is stated at every
- * call site rather than defaulted.
- */
-const derive = (schema, io) => z.toJSONSchema(schema, { io, unrepresentable: 'any' });
-const commitReceipt = () => jsonResp('Commit receipt', derive(commitReceiptSchema, 'output'));
-const modelParam = () => ({
-    name: 'model',
-    in: 'path',
-    required: true,
-    schema: { type: 'string' },
-    description: 'A model name from your pushed schema, e.g. `task`.',
-});
-const genericRow = () => ({ type: 'object', additionalProperties: true });
-/**
- * Fill in `data` on a derived model-response schema.
- *
- * The wire schemas type a row as `unknown`, because the transport that reads
- * them serves every schema and knows none of them. A reference has the opposite
- * need — a reader wants to see that `data` holds rows — so the envelope is
- * still derived, and only the one deliberately-open field is described. Both
- * shapes of that field are handled: an array for a list, a bare object for a
- * single read.
- */
-function withGenericRows(derived) {
-    const properties = { ...derived.properties };
-    if (!('data' in properties))
-        return derived;
-    properties.data =
-        properties.data?.type === 'array'
-            ? { type: 'array', items: genericRow() }
-            : genericRow();
-    return { ...derived, properties };
-}
-/** Query parameters derived from the schema the route reads them with. */
-function listQueryParams() {
-    const props = (derive(listQuerySchema, 'input').properties ?? {});
-    return Object.entries(props).map(([name, schema]) => ({ name, in: 'query', schema }));
-}
-/**
- * The `POST /v1/commits` body, derived from {@link commitRequestSchema} — the
- * same schema the server validates the request against.
- *
- * Deriving rather than describing is the point: a hand-written copy of this
- * shape would drift silently, and the tests would pin the copy to itself.
- */
-const commitBody = () => jsonBody(derive(commitRequestSchema, 'input'));
-/** The envelope shared by both specs — same server, same auth, same version. */
-function envelope(options, description, paths, schemas) {
-    return {
-        openapi: '3.1.0',
-        info: {
-            title: options.title ?? 'Ablo API',
-            version: options.version ?? '1.0.0',
-            description,
-        },
-        servers: [{ url: options.serverUrl ?? `${ABLO_HOSTED_HTTP_BASE_URL}/api` }],
-        security: [{ bearerAuth: [] }],
-        components: {
-            securitySchemes: {
-                bearerAuth: { type: 'http', scheme: 'bearer', description: 'Your Ablo API key (sk_… / rk_…).' },
-            },
-            schemas,
-        },
-        paths,
-    };
-}
-/**
- * The protocol reference: the five route templates the server actually serves,
- * plus `/v1/commits`.
- *
- * This takes no schema, and that is the point. The server registers one
- * parameterised route family (`/api/v1/models/:model/...`), so the API is five
- * routes no matter how many models a tenant defines — and a spec that cannot see
- * a schema cannot grow with one. It is publishable once, identical for every
- * caller, and stable across every schema push: the document a Python or Go
- * client is generated from, and the surface an agent is handed.
- *
- * Payload shapes are generic here by design. A caller that wants them typed
- * either reads the schema at runtime or generates the per-tenant expansion with
- * {@link schemaToOpenApi}.
- */
-export function abloOpenApi(options = {}) {
-    const rowResp = jsonResp('The row, with the watermark it was read at and who holds it.', withGenericRows(derive(modelReadResponseSchema, 'output')));
-    const writeBody = jsonBody(genericRow());
-    const tags = ['models'];
-    const paths = {
-        '/v1/models/{model}': {
-            get: {
-                tags,
-                summary: 'List rows of a model',
-                parameters: [modelParam(), ...listQueryParams()],
-                responses: {
-                    '200': jsonResp('A page of rows. `next_cursor` feeds `starting_after` on the next ' +
-                        'call; `stamp` is the watermark the page was read at.', withGenericRows(derive(modelListResponseSchema, 'output'))),
-                },
-            },
-            post: { tags, summary: 'Create a row', parameters: [modelParam()], requestBody: writeBody, responses: { '200': commitReceipt() } },
-        },
-        '/v1/models/{model}/{id}': {
-            get: { tags, summary: 'Retrieve a row', parameters: [modelParam(), idParam()], responses: { '200': rowResp } },
-            patch: { tags, summary: 'Update a row', parameters: [modelParam(), idParam()], requestBody: writeBody, responses: { '200': commitReceipt() } },
-            delete: { tags, summary: 'Delete a row', parameters: [modelParam(), idParam()], responses: { '200': commitReceipt() } },
-        },
-        '/v1/models/{model}/{id}/claim': {
-            post: {
-                tags: ['claims'],
-                summary: 'Claim a row (acquire lease)',
-                parameters: [modelParam(), idParam()],
-                requestBody: optionalJsonBody(derive(claimRequestSchema, 'input')),
-                responses: {
-                    '201': jsonResp('The lease is yours. `claim.fenceToken` is set when the coordinator ' +
-                        'minted one; carry it on writes made under the lease.', derive(claimAcquiredResponseSchema, 'output')),
-                    '202': jsonResp('The row was already held and you asked to queue. You are in line at ' +
-                        '`position` — heartbeat to keep the slot, and poll ' +
-                        '`GET /v1/claims/{claimId}` for the grant.', derive(claimQueuedResponseSchema, 'output')),
-                },
-            },
-            delete: { tags: ['claims'], summary: 'Release a claim', parameters: [modelParam(), idParam()], responses: { '200': jsonResp('Released', { type: 'object' }) } },
-        },
-        '/v1/models/{model}/{id}/claim/heartbeat': {
-            post: {
-                tags: ['claims'],
-                summary: 'Heartbeat a held claim (extend the lease for long-running work)',
-                parameters: [modelParam(), idParam()],
-                requestBody: optionalJsonBody(derive(claimHeartbeatRequestSchema, 'input')),
-                responses: {
-                    '200': jsonResp('Lease extended (or queued slot refreshed)', derive(claimHeartbeatReplySchema, 'output')),
-                },
-            },
-        },
-        '/v1/models/{model}/{id}/claim/reorder': {
-            post: { tags: ['claims'], summary: 'Reorder the wait-line (privileged)', parameters: [modelParam(), idParam()], responses: { '200': jsonResp('Reordered', { type: 'object' }) } },
-        },
-        '/v1/ephemeral_keys': {
-            post: {
-                tags: ['credentials'],
-                summary: 'Mint a short-lived session credential',
-                description: 'Call this first: every other route needs the key it returns. Requires a ' +
-                    'secret (`sk_`) key — a session cannot mint itself.',
-                parameters: [
-                    { name: 'Idempotency-Key', in: 'header', schema: { type: 'string' }, description: 'Replay-safe key; the server returns the cached credential on retry.' },
-                ],
-                requestBody: jsonBody(derive(ephemeralKeyRequestSchema, 'input')),
-                responses: { '200': jsonResp('The minted credential', derive(EphemeralKeyResponseSchema, 'output')) },
-            },
-        },
-        '/v1/claims/{claimId}': {
-            get: {
-                tags: ['claims'],
-                summary: 'Poll a claim for its current state',
-                description: 'How a caller without a persistent connection learns its queued claim ' +
-                    'was granted. `position` is advisory — a privileged reorder can move it ' +
-                    'up — so branch on `status`, never on position.',
-                parameters: [{ name: 'claimId', in: 'path', required: true, schema: { type: 'string' } }],
-                responses: { '200': jsonResp('The claim state', derive(claimStateSchema, 'output')) },
-            },
-            delete: {
-                tags: ['claims'],
-                summary: 'Release a claim, or leave the wait line',
-                description: 'The same call for both: releasing a held lease and abandoning a queued ' +
-                    'position are one operation, because a queue entry is a lease in a ' +
-                    'different state.',
-                parameters: [{ name: 'claimId', in: 'path', required: true, schema: { type: 'string' } }],
-                responses: { '200': jsonResp('Released', { type: 'object' }) },
-            },
-        },
-        '/v1/capabilities': {
-            post: {
-                tags: ['credentials'],
-                summary: 'Mint a capability for an agent or system',
-                description: 'A scoped, revocable grant. Narrow by default: an agent or system ' +
-                    'capability must name its `syncGroups` and `operations`.',
-                requestBody: jsonBody(derive(capabilityRequestSchema, 'input')),
-                responses: { '200': jsonResp('The minted capability', { type: 'object' }) },
-            },
-        },
-        '/v1/capabilities/{id}': {
-            get: {
-                tags: ['credentials'],
-                summary: 'Inspect a capability',
-                parameters: [idParam()],
-                responses: { '200': jsonResp('The capability', { type: 'object' }) },
-            },
-            delete: {
-                tags: ['credentials'],
-                summary: 'Revoke a capability',
-                parameters: [idParam()],
-                responses: { '200': jsonResp('Revoked', { type: 'object' }) },
-            },
-        },
-        '/v1/capabilities/{id}/rotate': {
-            post: {
-                tags: ['credentials'],
-                summary: 'Rotate a capability, keeping its grant',
-                parameters: [idParam()],
-                responses: { '200': jsonResp('The rotated capability', { type: 'object' }) },
-            },
-        },
-        '/v1/commits': {
-            post: {
-                tags: ['commits'],
-                summary: 'Commit a batch of operations atomically, and/or register durable premises',
-                parameters: [{ name: 'Idempotency-Key', in: 'header', schema: { type: 'string' }, description: 'Replay-safe key; the server returns the cached receipt on retry.' }],
-                requestBody: commitBody(),
-                responses: { '200': commitReceipt() },
-            },
-        },
-    };
-    return envelope(options, 'The Ablo transaction layer: commit, read, and claim. `{model}` is any model ' +
-        'from your pushed schema — the routes are the same whichever it is. ' +
-        'Authenticate every request with your API key as a Bearer token.', paths, {});
-}
-/**
- * The per-tenant expansion: every model's routes written out with typed payloads.
- *
- * Useful when you want generated types for one schema — five paths per model, so
- * it grows with the schema and is regenerated on every push. It documents the
- * same five routes {@link abloOpenApi} describes; it does not describe a
- * different API.
- */
-export function schemaToOpenApi(schema, options = {}) {
-    const models = schema.models;
-    const paths = {};
-    const schemas = {};
-    for (const [key, def] of Object.entries(models)) {
-        const ref = { $ref: `#/components/schemas/${pascal(key)}` };
-        const properties = { id: { type: 'string' } };
-        const required = ['id'];
-        const createProps = {};
-        for (const [fname, fmeta] of Object.entries(def.fields)) {
-            const fs = fieldSchema(fmeta);
-            properties[fname] = fs;
-            createProps[fname] = fs;
-            if (!fmeta.isOptional)
-                required.push(fname);
-        }
-        schemas[pascal(key)] = { type: 'object', properties, required };
-        const createBody = jsonBody({ type: 'object', properties: createProps });
-        paths[`/v1/models/${key}`] = {
-            get: {
-                tags: [key],
-                summary: `List ${key}`,
-                parameters: listQueryParams(),
-                responses: {
-                    '200': jsonResp('List of rows', {
-                        type: 'object',
-                        properties: { object: { type: 'string', enum: ['list'] }, data: { type: 'array', items: ref } },
-                    }),
-                },
-            },
-            post: { tags: [key], summary: `Create a ${key}`, requestBody: createBody, responses: { '200': commitReceipt() } },
-        };
-        paths[`/v1/models/${key}/{id}`] = {
-            get: {
-                tags: [key],
-                summary: `Retrieve a ${key}`,
-                parameters: [idParam()],
-                responses: {
-                    '200': jsonResp('The row', {
-                        type: 'object',
-                        properties: { data: ref, stamp: { type: 'integer' } },
-                    }),
-                },
-            },
-            patch: { tags: [key], summary: `Update a ${key}`, parameters: [idParam()], requestBody: createBody, responses: { '200': commitReceipt() } },
-            delete: { tags: [key], summary: `Delete a ${key}`, parameters: [idParam()], responses: { '200': commitReceipt() } },
-        };
-        paths[`/v1/models/${key}/{id}/claim`] = {
-            post: { tags: [key], summary: `Claim a ${key} (acquire lease)`, parameters: [idParam()], responses: { '200': jsonResp('Claim acquired', { type: 'object' }) } },
-            delete: { tags: [key], summary: `Release a ${key} claim`, parameters: [idParam()], responses: { '200': jsonResp('Released', { type: 'object' }) } },
-        };
-        paths[`/v1/models/${key}/{id}/claim/heartbeat`] = {
-            post: { tags: [key], summary: `Heartbeat a held ${key} claim (extend the lease for long-running work)`, parameters: [idParam()], responses: { '200': jsonResp('Lease extended (or queued slot refreshed)', derive(claimHeartbeatReplySchema, 'output')) } },
-        };
-        paths[`/v1/models/${key}/{id}/claim/reorder`] = {
-            post: { tags: [key], summary: `Reorder the ${key} wait-line (privileged)`, parameters: [idParam()], responses: { '200': jsonResp('Reordered', { type: 'object' }) } },
-        };
-    }
-    paths['/v1/commits'] = {
-        post: {
-            tags: ['commits'],
-            summary: 'Commit a batch of operations atomically, and/or register durable premises',
-            parameters: [{ name: 'Idempotency-Key', in: 'header', schema: { type: 'string' }, description: 'Replay-safe key; the server returns the cached receipt on retry.' }],
-            requestBody: commitBody(),
-            responses: { '200': commitReceipt() },
-        },
-    };
-    return envelope(options, 'Generated from your pushed Ablo schema — these routes are your models. ' +
-        'Authenticate every request with your API key as a Bearer token.', paths, schemas);
-}

package/dist/transaction/schema/relation.d.ts

@@ -1,199 +0,0 @@
-/**
- * Declarative relations between your models — the edges that turn a flat set
- * of models into a graph. You attach relations to a model with the
- * {@link relation} factories; the engine reads them to index foreign keys for
- * fast child lookups, to order inserts so a parent row lands before the rows
- * that reference it, and to generate the accessor properties that let you read
- * `task.project` or `project.tasks` directly.
- *
- * Usage:
- *   import { relation } from '@abloatai/ablo/schema';
- *
- *   const taskRelations = {
- *     project: relation.belongsTo('projects', 'projectId'),
- *     assignee: relation.belongsTo('users', 'assigneeId'),
- *     comments: relation.hasMany('comments', 'taskId'),
- *   };
- */
-/**
- * Options for `relation.belongsTo`. Each defaults to `false`, so every
- * behavior below is opt-in per relation.
- *
- * `index: true` registers a foreign-key index for the child model when the
- * engine starts, turning "every child that points at this parent" from a full
- * scan into a constant-time lookup. Reach for it on relations you query this
- * way often, such as a block's `sectionId`.
- *
- * `enrich: true` auto-populates the parent reference on an incoming change
- * before the child data lands. A change to `Task { teamId: 't1' }` picks up the
- * already-loaded `teams:t1` record and attaches it as `data.team`, so you can
- * read `task.team` without a second lookup. Enrichment is best-effort: if the
- * parent has not loaded yet it quietly does nothing, and the child data still
- * applies.
- *
- * `defer: true` tells the engine to ignore this edge when it works out the
- * order in which to insert rows. Use it on the soft side of a genuine reference
- * cycle — the side where you are willing to insert the child first with the
- * foreign key left null and fill it in with a later update. The other side of
- * the cycle then becomes a strict predecessor, so the child is ordered after
- * the parent rather than tied with it.
- *
- * `defer` changes only that ordering, not what the engine sends on the wire; it
- * does not rewrite an insert into an insert-then-update. Pair it with a Postgres
- * `DEFERRABLE INITIALLY DEFERRED` constraint when you also want the database to
- * relax the foreign-key check itself. For example:
- *
- *   ```ts
- *   layouts: model({ reportId: z.string().nullish() }, {
- *     // The report-owns-layout link is nullable and the layout is always
- *     // created first; marking it `defer` lets the report commit ahead of the
- *     // layout instead of sharing its insert-order slot.
- *     report: relation.belongsTo('reports', 'reportId', { defer: true }),
- *   }),
- *   ```
- */
-export interface BelongsToOptions {
-    readonly index?: boolean;
-    readonly enrich?: boolean;
-    readonly defer?: boolean;
-    /**
-     * Marks the relation's target as this record's parent: the entity the record
-     * lives inside and inherits its access scope from. When a record is written,
-     * the engine routes it into its parent's sync group — following a chain of
-     * `parent` edges all the way up — so the change reaches everyone subscribed to
-     * the owning entity. This is the familiar rule that access flows down from a
-     * container to the things it holds, as a folder does to its files.
-     *
-     * Do not set `parent` on a reference that merely points at another record for
-     * provenance or as a template, such as `sourceSectionId` or `templateId`; doing
-     * so would leak the record into an unrelated scope. The engine also cannot
-     * infer the parent from whether a field is optional — many real parent keys
-     * are optional, like a root folder or an inbox task — so you must declare the
-     * parent edge explicitly.
-     *
-     * It reads naturally at the call site:
-     * `belongsTo('report', 'reportId', { parent: true })` — the report is the parent.
-     */
-    readonly parent?: boolean;
-    /**
-     * Emit a real Postgres foreign-key constraint for this relation when the
-     * engine provisions tables in a customer-owned database. This is independent
-     * of `parent`: `parent` decides which subscribers a change reaches, while
-     * `fk` decides whether the database enforces referential integrity. A relation
-     * may set either, both, or neither.
-     *
-     * Set `fk: true` only when the target row lives in the same database and is
-     * written in the same commit as this row, and points at a strong, contained
-     * entity. Leave it off provenance or template pointers (`sourceSectionId`,
-     * `templateId`), cross-tenant references, or anything that may be written in a
-     * different transaction than its target — a hard constraint there would reject
-     * the write and break out-of-order sync. The constraint is emitted as
-     * `DEFERRABLE INITIALLY DEFERRED, ON DELETE NO ACTION`: a plain integrity
-     * guard, leaving any cascade or null-on-delete behavior to the application.
-     */
-    readonly fk?: boolean;
-}
-declare const __relationType: unique symbol;
-declare const __relationTarget: unique symbol;
-declare const __relationField: unique symbol;
-export type RelationType = 'belongsTo' | 'hasMany' | 'hasOne';
-/**
- * A relation definition, carrying its type information at both the type and
- * runtime level.
- *
- * The `Options` generic captures a relation's options in the type system; only
- * `belongsTo` uses it, while `hasMany` and `hasOne` leave it empty. The `const`
- * modifier on the `belongsTo` factory preserves literal inference, so
- * `{ enrich: true }` is remembered as `true` rather than widened to `boolean`,
- * letting type-level features read the exact option value.
- *
- * `options` is always present at runtime: the factory substitutes an empty
- * object when you omit it, so reading `options.index` or `options.enrich` needs
- * no null check.
- */
-export interface RelationDef<Type extends RelationType = RelationType, Target extends string = string, Field extends string = string, Options extends BelongsToOptions = BelongsToOptions> {
-    readonly [__relationType]: Type;
-    readonly [__relationTarget]: Target;
-    readonly [__relationField]: Field;
-    /** Runtime metadata */
-    readonly type: Type;
-    readonly target: Target;
-    /**
-     * The field on the child model that holds the parent's id, as a camelCase
-     * schema field name. The engine reads `model[foreignKey]` to resolve the
-     * relation and to build client-side index keys; it is never interpolated into
-     * raw SQL — that is what {@link foreignKeyColumn} is for.
-     */
-    readonly foreignKey: Field;
-    /**
-     * The same foreign key expressed as a database column identifier.
-     * {@link foreignKey} is translated into this when you configure a `casing`
-     * option on `defineSchema` — for example `'snake_case'` turns `messageId`
-     * into `message_id`. The server interpolates this column name into SQL
-     * directly, because a driver's automatic camelCase-to-snake_case mapping does
-     * not reach identifiers embedded in raw SQL; resolving the name once at
-     * schema-build time is what makes it available there.
-     *
-     * Defaults to {@link foreignKey} when no `casing` option is set, so consumers
-     * whose database columns already match their field names need no
-     * configuration.
-     */
-    readonly foreignKeyColumn: string;
-    readonly options: Options;
-    /**
-     * Optional sort field for `hasMany` relations. When set, the
-     * generated relation getter sorts results by this field. Populated
-     * by `relation.hasMany(target, fk, { orderBy: 'fieldName' })`.
-     */
-    readonly _orderBy?: string;
-}
-export declare const relation: {
-    /**
-     * This model belongs to another model via a foreign key.
-     * e.g., Task belongs to Project via projectId
-     *
-     * ```ts
-     * // Simple reference (no options)
-     * project: relation.belongsTo('projects', 'projectId'),
-     *
-     * // Register an FK index for O(1) child lookups
-     * section: relation.belongsTo('sections', 'sectionId', { index: true }),
-     *
-     * // Auto-populate the parent on delta arrival
-     * team: relation.belongsTo('teams', 'teamId', { enrich: true }),
-     *
-     * // Both
-     * parent: relation.belongsTo('threads', 'parentId', { index: true, enrich: true }),
-     *
-     * // Mark the soft side of a cycle so the priority computer breaks
-     * // the cycle deterministically instead of tying the two models.
-     * report: relation.belongsTo('reports', 'reportId', { defer: true }),
-     * ```
-     */
-    readonly belongsTo: <Target extends string, Field extends string, const Opts extends BelongsToOptions = Record<string, never>>(target: Target, foreignKey: Field, options?: Opts) => RelationDef<"belongsTo", Target, Field, Opts>;
-    /**
-     * This model has many of another model — for example, a project has many
-     * tasks via `Task.projectId`.
-     *
-     * At runtime the engine adds a getter to the parent model that returns every
-     * child whose foreign key matches, and registers the foreign-key index on the
-     * child model automatically.
-     *
-     * ```ts
-     * blocks: relation.hasMany('blocks', 'sectionId'),
-     * // → section.blocks returns all Block[] where sectionId === section.id
-     *
-     * blocks: relation.hasMany('blocks', 'sectionId', { orderBy: 'zIndex' }),
-     * // → section.blocks returns Block[] sorted by zIndex ascending
-     * ```
-     */
-    readonly hasMany: <Target extends string, Field extends string>(target: Target, foreignKey: Field, options?: {
-        orderBy?: string;
-    }) => RelationDef<"hasMany", Target, Field>;
-    /**
-     * This model has one of another model — for example, a user has one profile
-     * via `Profile.userId`.
-     */
-    readonly hasOne: <Target extends string, Field extends string>(target: Target, foreignKey: Field) => RelationDef<"hasOne", Target, Field>;
-};
-export {};

package/dist/transaction/schema/relation.js

@@ -1,104 +0,0 @@
-/**
- * Declarative relations between your models — the edges that turn a flat set
- * of models into a graph. You attach relations to a model with the
- * {@link relation} factories; the engine reads them to index foreign keys for
- * fast child lookups, to order inserts so a parent row lands before the rows
- * that reference it, and to generate the accessor properties that let you read
- * `task.project` or `project.tasks` directly.
- *
- * Usage:
- *   import { relation } from '@abloatai/ablo/schema';
- *
- *   const taskRelations = {
- *     project: relation.belongsTo('projects', 'projectId'),
- *     assignee: relation.belongsTo('users', 'assigneeId'),
- *     comments: relation.hasMany('comments', 'taskId'),
- *   };
- */
-// ── Internal relation builder ─────────────────────────────────────────────
-class RelationBuilder {
-    type;
-    target;
-    foreignKey;
-    /**
-     * Starts out identical to {@link foreignKey}. `defineSchema` overwrites
-     * this when a `casing` option is set — it's declared as a mutable
-     * (non-readonly on the implementation side) so the schema builder can
-     * resolve it once at build time without allocating a new object per
-     * relation. Consumers see it typed as `readonly` on {@link RelationDef}.
-     */
-    foreignKeyColumn;
-    options;
-    /**
-     * Stashed by `hasMany` when the caller provides `{ orderBy }`. Read
-     * back in `createSyncEngine` to install the sort comparator on the
-     * generated relation getter. Declared on the builder so both writer
-     * and reader stay type-safe — no double-cast smuggle through `Record<...>`.
-     */
-    _orderBy;
-    constructor(type, target, foreignKey, options) {
-        this.type = type;
-        this.target = target;
-        this.foreignKey = foreignKey;
-        this.foreignKeyColumn = foreignKey;
-        this.options = (options ?? {});
-    }
-}
-// ── Public relation factories ─────────────────────────────────────────────
-export const relation = {
-    /**
-     * This model belongs to another model via a foreign key.
-     * e.g., Task belongs to Project via projectId
-     *
-     * ```ts
-     * // Simple reference (no options)
-     * project: relation.belongsTo('projects', 'projectId'),
-     *
-     * // Register an FK index for O(1) child lookups
-     * section: relation.belongsTo('sections', 'sectionId', { index: true }),
-     *
-     * // Auto-populate the parent on delta arrival
-     * team: relation.belongsTo('teams', 'teamId', { enrich: true }),
-     *
-     * // Both
-     * parent: relation.belongsTo('threads', 'parentId', { index: true, enrich: true }),
-     *
-     * // Mark the soft side of a cycle so the priority computer breaks
-     * // the cycle deterministically instead of tying the two models.
-     * report: relation.belongsTo('reports', 'reportId', { defer: true }),
-     * ```
-     */
-    belongsTo(target, foreignKey, options) {
-        return new RelationBuilder('belongsTo', target, foreignKey, options ?? {});
-    },
-    /**
-     * This model has many of another model — for example, a project has many
-     * tasks via `Task.projectId`.
-     *
-     * At runtime the engine adds a getter to the parent model that returns every
-     * child whose foreign key matches, and registers the foreign-key index on the
-     * child model automatically.
-     *
-     * ```ts
-     * blocks: relation.hasMany('blocks', 'sectionId'),
-     * // → section.blocks returns all Block[] where sectionId === section.id
-     *
-     * blocks: relation.hasMany('blocks', 'sectionId', { orderBy: 'zIndex' }),
-     * // → section.blocks returns Block[] sorted by zIndex ascending
-     * ```
-     */
-    hasMany(target, foreignKey, options) {
-        const builder = new RelationBuilder('hasMany', target, foreignKey);
-        if (options?.orderBy) {
-            builder._orderBy = options.orderBy;
-        }
-        return builder;
-    },
-    /**
-     * This model has one of another model — for example, a user has one profile
-     * via `Profile.userId`.
-     */
-    hasOne(target, foreignKey) {
-        return new RelationBuilder('hasOne', target, foreignKey);
-    },
-};

package/dist/transaction/schema/residency.d.ts

@@ -1,29 +0,0 @@
-/**
- * A model's residency: which database its rows live in. This is a sibling axis
- * to `tenancy`, which instead describes how rows are isolated within a single
- * database.
- *
- *   - `tenant`  — the tenant data plane. For a customer-connected database this
- *                 is the customer's own database, and provisioning creates these
- *                 tables there.
- *   - `control` — the coordination plane the engine owns: the change log,
- *                 attribution, audit, and the like. These tables are never
- *                 created in a customer's database.
- *
- * The name is `residency` rather than `plane` because "plane" already refers to
- * the server's tenancy scope — organization, environment, and optionally
- * project and sandbox. On the wire the serialized option is still keyed as
- * `plane`, a frozen part of the wire format; only the TypeScript name differs.
- *
- * Declaring this boundary lets provisioning derive what a customer's database
- * receives — the models whose residency is `tenant` — rather than hand-coding
- * that list. Defaults to `tenant`.
- */
-import { z } from 'zod';
-export declare const residencySchema: z.ZodEnum<{
-    tenant: "tenant";
-    control: "control";
-}>;
-export type ModelResidency = z.infer<typeof residencySchema>;
-/** Default residency for a model that doesn't declare one — the tenant data plane. */
-export declare const DEFAULT_RESIDENCY: ModelResidency;