@abloatai/ablo 0.35.0 → 0.36.0

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 '../../transaction/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 '../../stores/syncAction.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/httpResponses.d.ts

@@ -1,70 +0,0 @@
-/**
- * Response bodies for a fake HTTP server, built in the shapes the real one
- * answers with.
- *
- * A test that hand-rolls `{ data, stamp }` is asserting against a server it
- * invented. That is how a client and its server drift apart while every test
- * stays green: the fixture and the client agree, and neither has met the
- * route. Each builder here is `satisfies`-pinned to the wire schema the server
- * answers with and the client parses — so a change to the contract breaks these
- * fixtures at compile time, and the tests that use them describe a server that
- * exists.
- *
- * Only the fields a test actually varies are parameters; everything else is a
- * plausible default, because a fixture that makes you fill in `object: 'model'`
- * teaches nothing and gets copy-pasted wrong.
- */
-import type { ModelReadResponse, ModelListResponse, ClaimAcquiredResponse, ClaimQueuedResponse, ClaimListResponse, ClaimHeartbeatReply } from '../../transaction/wire/index.js';
-import type { ModelClaim } from '../../transaction/coordination/index.js';
-/** `GET /v1/models/{model}/{id}`. Pass `data: null` for a miss. */
-export declare function modelReadResponse(args: {
-    model: string;
-    id: string;
-    data: unknown;
-    stamp?: number;
-    claims?: readonly ModelClaim[];
-}): ModelReadResponse;
-/** `GET /v1/models/{model}`. */
-export declare function modelListResponse(args: {
-    model: string;
-    data: readonly unknown[];
-    hasMore?: boolean;
-    nextCursor?: string | null;
-    stamp?: number;
-}): ModelListResponse;
-/** One claim in the shape the HTTP claim routes return it. */
-export declare function modelClaim(args: {
-    id: string;
-    model: string;
-    entityId: string;
-    actor?: string;
-    participantKind?: ModelClaim['participantKind'];
-    description?: string;
-    status?: 'active' | 'queued';
-    position?: number;
-    expiresAt?: number;
-    fenceToken?: number;
-    field?: string;
-}): ModelClaim;
-/** `POST /v1/models/{model}/{id}/claim` — 201, the lease is yours. */
-export declare function claimAcquiredResponse(claim: ModelClaim): ClaimAcquiredResponse;
-/** `POST /v1/models/{model}/{id}/claim` — 202, you are in the wait line. */
-export declare function claimQueuedResponse(args: {
-    claimId: string;
-    position: number;
-    heldBy?: string;
-    expiresAt?: number;
-}): ClaimQueuedResponse;
-/** `GET /v1/claims`. */
-export declare function claimListResponse(args?: {
-    claims?: readonly ModelClaim[];
-    queue?: readonly ModelClaim[];
-}): ClaimListResponse;
-/** `POST /v1/models/{model}/{id}/claim/heartbeat`. */
-export declare function claimHeartbeatReply(args: {
-    claimId: string;
-    status?: 'held' | 'queued';
-    expiresAt?: number;
-    queueDepth?: number;
-    position?: number;
-}): ClaimHeartbeatReply;

package/dist/testing/fixtures/httpResponses.js

@@ -1,90 +0,0 @@
-/**
- * Response bodies for a fake HTTP server, built in the shapes the real one
- * answers with.
- *
- * A test that hand-rolls `{ data, stamp }` is asserting against a server it
- * invented. That is how a client and its server drift apart while every test
- * stays green: the fixture and the client agree, and neither has met the
- * route. Each builder here is `satisfies`-pinned to the wire schema the server
- * answers with and the client parses — so a change to the contract breaks these
- * fixtures at compile time, and the tests that use them describe a server that
- * exists.
- *
- * Only the fields a test actually varies are parameters; everything else is a
- * plausible default, because a fixture that makes you fill in `object: 'model'`
- * teaches nothing and gets copy-pasted wrong.
- */
-/** `GET /v1/models/{model}/{id}`. Pass `data: null` for a miss. */
-export function modelReadResponse(args) {
-    return {
-        object: 'model',
-        model: args.model,
-        id: args.id,
-        data: args.data,
-        stamp: args.stamp ?? 0,
-        claims: args.claims ?? [],
-    };
-}
-/** `GET /v1/models/{model}`. */
-export function modelListResponse(args) {
-    return {
-        object: 'list',
-        model: args.model,
-        data: [...args.data],
-        has_more: args.hasMore ?? false,
-        next_cursor: args.nextCursor ?? null,
-        stamp: args.stamp ?? 0,
-    };
-}
-/** One claim in the shape the HTTP claim routes return it. */
-export function modelClaim(args) {
-    return {
-        id: args.id,
-        actor: args.actor ?? 'user_fixture',
-        participantKind: args.participantKind ?? 'user',
-        description: args.description ?? 'editing',
-        ...(args.field !== undefined ? { field: args.field } : {}),
-        ...(args.status !== undefined ? { status: args.status } : {}),
-        ...(args.position !== undefined ? { position: args.position } : {}),
-        expiresAt: args.expiresAt ?? Date.now() + 60_000,
-        ...(args.fenceToken !== undefined ? { fenceToken: args.fenceToken } : {}),
-        target: { model: args.model, id: args.entityId },
-    };
-}
-/** `POST /v1/models/{model}/{id}/claim` — 201, the lease is yours. */
-export function claimAcquiredResponse(claim) {
-    return { id: claim.id, object: 'claim', claim };
-}
-/** `POST /v1/models/{model}/{id}/claim` — 202, you are in the wait line. */
-export function claimQueuedResponse(args) {
-    return {
-        status: 'queued',
-        claimId: args.claimId,
-        position: args.position,
-        ...(args.heldBy !== undefined ? { heldBy: args.heldBy } : {}),
-        ...(args.expiresAt !== undefined ? { expiresAt: args.expiresAt } : {}),
-    };
-}
-/** `GET /v1/claims`. */
-export function claimListResponse(args = {}) {
-    return {
-        object: 'list',
-        claims: args.claims ?? [],
-        queue: args.queue ?? [],
-    };
-}
-/** `POST /v1/models/{model}/{id}/claim/heartbeat`. */
-export function claimHeartbeatReply(args) {
-    const status = args.status ?? 'held';
-    return {
-        object: 'claim_heartbeat',
-        claimId: args.claimId,
-        status,
-        ...(status === 'held'
-            ? {
-                expiresAt: args.expiresAt ?? Date.now() + 60_000,
-                ...(args.queueDepth !== undefined ? { queueDepth: args.queueDepth } : {}),
-            }
-            : { position: args.position ?? 0 }),
-    };
-}

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;