@abloatai/ablo 0.34.1 → 0.36.0

package/dist/schema/openapi.js

@@ -1,124 +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 '../client/hostedEndpoints.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 } },
-});
-const jsonResp = (description, schema) => ({
-    description,
-    content: { 'application/json': { schema } },
-});
-const commitReceipt = () => jsonResp('Commit receipt', {
-    type: 'object',
-    properties: {
-        object: { type: 'string', enum: ['commit_receipt'] },
-        clientTxId: { type: 'string' },
-        serverTxId: { type: 'string' },
-        success: { type: 'boolean' },
-        lastSyncId: { type: 'integer' },
-    },
-});
-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: [
-                    { name: 'limit', in: 'query', schema: { type: 'integer' } },
-                    { name: 'order_by', in: 'query', schema: { type: 'string' } },
-                    { name: 'order', in: 'query', schema: { type: 'string', enum: ['asc', 'desc'] } },
-                ],
-                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)', { type: 'object', properties: { object: { type: 'string', enum: ['claim_heartbeat'] }, claimId: { type: 'string' }, status: { type: 'string', enum: ['held', 'queued'] }, expiresAt: { type: 'integer' }, position: { type: 'integer' } } }) } },
-        };
-        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', responses: { '200': commitReceipt() } },
-    };
-    return {
-        openapi: '3.1.0',
-        info: {
-            title: options.title ?? 'Ablo API',
-            version: options.version ?? '1.0.0',
-            description: 'Generated from your pushed Ablo schema — these routes are your models. ' +
-                'Authenticate every request with your API key as a Bearer token.',
-        },
-        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,
-    };
-}

package/dist/testing/fixtures/bootstrap.d.ts

@@ -1,49 +0,0 @@
-/**
- * Factories that build well-formed bootstrap responses for tests. A
- * bootstrap response is what the server returns when a client first syncs:
- * either a full snapshot of the models or a partial batch of deltas since a
- * known point. These helpers produce the same shapes, so tests can exercise
- * client sync logic without a live server.
- */
-import type { BootstrapType } from '../../types/index.js';
-export type BootstrapModelData = Record<string, Record<string, unknown>[]>;
-export interface BootstrapResponse {
-    type: BootstrapType;
-    lastSyncId: number;
-    models?: BootstrapModelData;
-    deltas?: {
-        id: number;
-        modelName: string;
-        modelId: string;
-        action: string;
-        data: Record<string, unknown>;
-    }[];
-    deltaCount?: number;
-    failedModels?: string[];
-    timestamp: number;
-}
-/**
- * Builds a full bootstrap response — a fresh snapshot of the given models,
- * as the server sends on a client's first sync.
- */
-export declare function createFullBootstrapResponse(models: BootstrapModelData, lastSyncId?: number): BootstrapResponse;
-/**
- * Builds a partial bootstrap response — a batch of deltas applied on top of
- * the client's last known sync point, given by `lastSyncId`.
- */
-export declare function createPartialBootstrapResponse(deltas: BootstrapResponse['deltas'], lastSyncId: number): BootstrapResponse;
-/**
- * Builds a full bootstrap response with the common test models
- * pre-populated. Pass any of the named model arrays to include them in the
- * snapshot.
- */
-export declare function createTestBootstrapResponse(options?: {
-    tasks?: Record<string, unknown>[];
-    projects?: Record<string, unknown>[];
-    slideDecks?: Record<string, unknown>[];
-    slides?: Record<string, unknown>[];
-    slideLayers?: Record<string, unknown>[];
-    comments?: Record<string, unknown>[];
-    lastSyncId?: number;
-    failedModels?: string[];
-}): BootstrapResponse;

package/dist/testing/fixtures/bootstrap.js

@@ -1,59 +0,0 @@
-/**
- * Factories that build well-formed bootstrap responses for tests. A
- * bootstrap response is what the server returns when a client first syncs:
- * either a full snapshot of the models or a partial batch of deltas since a
- * known point. These helpers produce the same shapes, so tests can exercise
- * client sync logic without a live server.
- */
-/**
- * Builds a full bootstrap response — a fresh snapshot of the given models,
- * as the server sends on a client's first sync.
- */
-export function createFullBootstrapResponse(models, lastSyncId = 100) {
-    return {
-        type: 'full',
-        lastSyncId,
-        models,
-        timestamp: Date.now(),
-    };
-}
-/**
- * Builds a partial bootstrap response — a batch of deltas applied on top of
- * the client's last known sync point, given by `lastSyncId`.
- */
-export function createPartialBootstrapResponse(deltas, lastSyncId) {
-    return {
-        type: 'partial',
-        lastSyncId,
-        deltas,
-        deltaCount: deltas?.length ?? 0,
-        timestamp: Date.now(),
-    };
-}
-/**
- * Builds a full bootstrap response with the common test models
- * pre-populated. Pass any of the named model arrays to include them in the
- * snapshot.
- */
-export function createTestBootstrapResponse(options = {}) {
-    const models = {};
-    if (options.tasks)
-        models.Task = options.tasks;
-    if (options.projects)
-        models.Project = options.projects;
-    if (options.slideDecks)
-        models.SlideDeck = options.slideDecks;
-    if (options.slides)
-        models.Slide = options.slides;
-    if (options.slideLayers)
-        models.SlideLayer = options.slideLayers;
-    if (options.comments)
-        models.Comment = options.comments;
-    return {
-        type: 'full',
-        lastSyncId: options.lastSyncId ?? 100,
-        models,
-        failedModels: options.failedModels,
-        timestamp: Date.now(),
-    };
-}

package/dist/testing/fixtures/deltas.d.ts

@@ -1,83 +0,0 @@
-/**
- * Factories that build well-formed delta objects for tests. A delta, a
- * {@link SyncAction}, is a single change to one model instance in the wire
- * format the server sends: an insert, update, delete, archive, and so on.
- * These helpers let tests construct deltas without a live server.
- */
-import type { SyncActionType, SyncAction } from '../../types/index.js';
-/** Reset the delta counter (call in beforeEach for deterministic IDs) */
-export declare function resetDeltaCounter(): void;
-export interface CreateDeltaOptions {
-    /** Sync ID (auto-increments if not provided) */
-    id?: number;
-    /** Model name (e.g., 'Task', 'Slide') */
-    modelName: string;
-    /** Model ID */
-    modelId: string;
-    /** Action type: I=Insert, U=Update, D=Delete, A=Archive, V=Unarchive */
-    action: SyncActionType;
-    /** Delta payload data */
-    data?: Record<string, unknown>;
-}
-/**
- * Builds a single delta ({@link SyncAction}) in the server's wire format.
- */
-export declare function createDelta(options: CreateDeltaOptions): SyncAction;
-/**
- * Builds an insert delta for a new entity.
- */
-export declare function createInsertDelta(modelName: string, modelId: string, data: Record<string, unknown>, syncId?: number): SyncAction;
-/**
- * Builds an update delta for an existing entity.
- */
-export declare function createUpdateDelta(modelName: string, modelId: string, data: Record<string, unknown>, syncId?: number): SyncAction;
-/**
- * Builds a delete delta.
- */
-export declare function createDeleteDelta(modelName: string, modelId: string, syncId?: number): SyncAction;
-/**
- * Builds an archive delta, stamping `archivedAt` with the current time.
- */
-export declare function createArchiveDelta(modelName: string, modelId: string, syncId?: number): SyncAction;
-/**
- * Builds an unarchive delta, clearing `archivedAt`.
- */
-export declare function createUnarchiveDelta(modelName: string, modelId: string, syncId?: number): SyncAction;
-/**
- * Builds a covering ('C') delta. It signals that the client has gained
- * permission to see an entity that already exists. The client treats it
- * like an insert, adding the entity to its local store as if newly created.
- * A covering delta typically follows a group-added delta.
- */
-export declare function createCoveringDelta(modelName: string, modelId: string, data: Record<string, unknown>, syncId?: number): SyncAction;
-/**
- * Builds a group-added ('G') delta in the incremental payload shape. It
- * signals that the recipient was added to a single sync group. The client
- * updates its subscription state and waits for covering deltas to deliver
- * the newly visible entities. Unlike the older payload that carries both
- * added and removed groups, this shape does not trigger a re-bootstrap.
- */
-export declare function createGroupAddedDelta(userId: string, group: string, syncId?: number): SyncAction;
-/**
- * Builds a group-change ('G') delta in the older payload shape, which
- * carries both added and removed groups in one delta and forces a full
- * re-bootstrap on the client. Useful for testing backward compatibility
- * with that older shape.
- */
-export declare function createLegacyGroupChangeDelta(userId: string, added: string[], removed: string[], syncId?: number): SyncAction;
-/**
- * Builds a group-removed ('S') delta. It signals that the recipient lost
- * access to a sync group. The client purges the affected local state and
- * re-bootstraps with the updated group list.
- */
-export declare function createGroupRemovedDelta(userId: string, group: string, syncId?: number): SyncAction;
-/**
- * Builds a batch of deltas with sequential sync IDs.
- */
-export declare function createDeltaBatch(deltas: Omit<CreateDeltaOptions, 'id'>[], startingSyncId?: number): SyncAction[];
-/**
- * Builds a confirmation delta, which signals that a mutation was persisted
- * by the server. The client's transaction queue watches for these to
- * confirm its in-flight writes.
- */
-export declare function createConfirmationDelta(modelName: string, modelId: string, syncId: number, action?: SyncActionType, data?: Record<string, unknown>): SyncAction;

package/dist/testing/fixtures/deltas.js

@@ -1,136 +0,0 @@
-/**
- * Factories that build well-formed delta objects for tests. A delta, a
- * {@link SyncAction}, is a single change to one model instance in the wire
- * format the server sends: an insert, update, delete, archive, and so on.
- * These helpers let tests construct deltas without a live server.
- */
-let deltaCounter = 0;
-/** Reset the delta counter (call in beforeEach for deterministic IDs) */
-export function resetDeltaCounter() {
-    deltaCounter = 0;
-}
-/**
- * Builds a single delta ({@link SyncAction}) in the server's wire format.
- */
-export function createDelta(options) {
-    deltaCounter++;
-    return {
-        id: options.id ?? deltaCounter,
-        modelName: options.modelName,
-        modelId: options.modelId,
-        action: options.action,
-        data: options.data ?? {},
-        __class: 'SyncAction',
-    };
-}
-/**
- * Builds an insert delta for a new entity.
- */
-export function createInsertDelta(modelName, modelId, data, syncId) {
-    return createDelta({ modelName, modelId, action: 'I', data, id: syncId });
-}
-/**
- * Builds an update delta for an existing entity.
- */
-export function createUpdateDelta(modelName, modelId, data, syncId) {
-    return createDelta({ modelName, modelId, action: 'U', data, id: syncId });
-}
-/**
- * Builds a delete delta.
- */
-export function createDeleteDelta(modelName, modelId, syncId) {
-    return createDelta({ modelName, modelId, action: 'D', data: {}, id: syncId });
-}
-/**
- * Builds an archive delta, stamping `archivedAt` with the current time.
- */
-export function createArchiveDelta(modelName, modelId, syncId) {
-    return createDelta({
-        modelName,
-        modelId,
-        action: 'A',
-        data: { archivedAt: new Date().toISOString() },
-        id: syncId,
-    });
-}
-/**
- * Builds an unarchive delta, clearing `archivedAt`.
- */
-export function createUnarchiveDelta(modelName, modelId, syncId) {
-    return createDelta({
-        modelName,
-        modelId,
-        action: 'V',
-        data: { archivedAt: null },
-        id: syncId,
-    });
-}
-/**
- * Builds a covering ('C') delta. It signals that the client has gained
- * permission to see an entity that already exists. The client treats it
- * like an insert, adding the entity to its local store as if newly created.
- * A covering delta typically follows a group-added delta.
- */
-export function createCoveringDelta(modelName, modelId, data, syncId) {
-    return createDelta({ modelName, modelId, action: 'C', data, id: syncId });
-}
-/**
- * Builds a group-added ('G') delta in the incremental payload shape. It
- * signals that the recipient was added to a single sync group. The client
- * updates its subscription state and waits for covering deltas to deliver
- * the newly visible entities. Unlike the older payload that carries both
- * added and removed groups, this shape does not trigger a re-bootstrap.
- */
-export function createGroupAddedDelta(userId, group, syncId) {
-    return createDelta({
-        modelName: 'SyncGroupChange',
-        modelId: `sga_${userId}`,
-        action: 'G',
-        data: { group, userId },
-        id: syncId,
-    });
-}
-/**
- * Builds a group-change ('G') delta in the older payload shape, which
- * carries both added and removed groups in one delta and forces a full
- * re-bootstrap on the client. Useful for testing backward compatibility
- * with that older shape.
- */
-export function createLegacyGroupChangeDelta(userId, added, removed, syncId) {
-    return createDelta({
-        modelName: 'SyncGroupChange',
-        modelId: `sgc_${userId}`,
-        action: 'G',
-        data: { addedGroups: added, removedGroups: removed },
-        id: syncId,
-    });
-}
-/**
- * Builds a group-removed ('S') delta. It signals that the recipient lost
- * access to a sync group. The client purges the affected local state and
- * re-bootstraps with the updated group list.
- */
-export function createGroupRemovedDelta(userId, group, syncId) {
-    return createDelta({
-        modelName: 'SyncGroupChange',
-        modelId: `sgr_${userId}`,
-        action: 'S',
-        data: { group, userId },
-        id: syncId,
-    });
-}
-/**
- * Builds a batch of deltas with sequential sync IDs.
- */
-export function createDeltaBatch(deltas, startingSyncId) {
-    const start = startingSyncId ?? deltaCounter + 1;
-    return deltas.map((d, i) => createDelta({ ...d, id: start + i }));
-}
-/**
- * Builds a confirmation delta, which signals that a mutation was persisted
- * by the server. The client's transaction queue watches for these to
- * confirm its in-flight writes.
- */
-export function createConfirmationDelta(modelName, modelId, syncId, action = 'U', data = {}) {
-    return createDelta({ modelName, modelId, action, data, id: syncId });
-}

package/dist/testing/fixtures/models.d.ts

@@ -1,83 +0,0 @@
-/**
- * A small set of {@link Model} subclasses used across the package's tests.
- * They form two foreign-key chains and carry the creation priorities the
- * transaction queue uses to order dependent writes:
- *   TestProject (10) → TestTask (10, references Project) → TestComment (30, references Task)
- *   TestSlideDeck (10) → TestSlide (15, references SlideDeck) → TestSlideLayer (20, references Slide)
- */
-import { Model } from '../../Model.js';
-import { ModelRegistry } from '../../ModelRegistry.js';
-export declare class TestProject extends Model {
-    name: string;
-    description: string;
-    organizationId: string;
-    constructor(data?: Partial<TestProject> & Record<string, unknown>);
-    getModelName(): string;
-}
-export declare class TestTask extends Model {
-    title: string;
-    status: string;
-    projectId: string | null;
-    assigneeId: string | null;
-    organizationId: string;
-    constructor(data?: Partial<TestTask> & Record<string, unknown>);
-    getModelName(): string;
-}
-export declare class TestComment extends Model {
-    body: string;
-    taskId: string | null;
-    organizationId: string;
-    constructor(data?: Partial<TestComment> & Record<string, unknown>);
-    getModelName(): string;
-}
-export declare class TestSlideDeck extends Model {
-    title: string;
-    organizationId: string;
-    constructor(data?: Partial<TestSlideDeck> & Record<string, unknown>);
-    getModelName(): string;
-}
-export declare class TestSlide extends Model {
-    order: number;
-    deckId: string | null;
-    organizationId: string;
-    constructor(data?: Partial<TestSlide> & Record<string, unknown>);
-    getModelName(): string;
-}
-export declare class TestSlideLayer extends Model {
-    slideId: string | null;
-    zIndex: number;
-    type: string;
-    content: string;
-    organizationId: string;
-    constructor(data?: Partial<TestSlideLayer> & Record<string, unknown>);
-    getModelName(): string;
-}
-/**
- * Maps each test model to its creation priority, matching the order the
- * transaction queue uses when writing dependent models.
- */
-export declare const TEST_MODEL_PRIORITIES: Map<string, number>;
-/**
- * Registers every test model with a {@link ModelRegistry}, wiring up their
- * properties, references, and foreign-key relationships.
- */
-export declare function registerTestModels(registry: ModelRegistry): void;
-/**
- * Builds a sync engine configuration pre-loaded with the test models'
- * creation priorities and related settings.
- */
-export declare function createTestConfig(): {
-    modelCreatePriority: ReadonlyMap<string, number>;
-    defaultCreatePriority: number;
-    defaultNonCreatePriority: number;
-    essentialFields: Readonly<Record<string, readonly string[]>>;
-    classNameFallbackMap: Readonly<Record<string, string>>;
-};
-/** Reset the counter (call in beforeEach for deterministic IDs) */
-export declare function resetFixtureCounter(): void;
-export declare function createProjectFixture(overrides?: Partial<Record<string, unknown>>): TestProject;
-export declare function createTaskFixture(overrides?: Partial<Record<string, unknown>>): TestTask;
-export declare function createCommentFixture(overrides?: Partial<Record<string, unknown>>): TestComment;
-export declare function createSlideDeckFixture(overrides?: Partial<Record<string, unknown>>): TestSlideDeck;
-export declare function createSlideFixture(overrides?: Partial<Record<string, unknown>>): TestSlide;
-export declare function createSlideLayerFixture(overrides?: Partial<Record<string, unknown>>): TestSlideLayer;