ai-database 2.1.3 → 2.3.0

package/dist/cascade-write-strategy.js

@@ -0,0 +1,590 @@
+/**
+ * Cascade Write Strategy — sharded parallel writes for cascade generation
+ *
+ * Phase 2 entry point of the cascade epic per
+ * [ADR-0003](../../../docs/adr/0003-storage-strategy-pg-clickhouse-default.md)
+ * and the
+ * [implementation plan](../../../docs/plans/2026-05-05-cascade-storage-execution-implementation.md).
+ *
+ * This module is **strategy + scaffolding** — the *primitive* the cascade
+ * orchestrator (`aip-8yal`) calls. It does not run the orchestration loop
+ * itself, does not call LLMs, and does not implement the dual-write to
+ * Pipelines/Iceberg fan-out (that's `aip-0ypt`). It does:
+ *
+ * 1. **Shard-key derivation** — given a cascade context, pick the
+ *    {@link ShardRef} the next batch should land in. Built-in strategies
+ *    cover the three sharding models declared on `DBProvider`:
+ *    `per-cascade` (DO SQLite default), `partitioned-by-tenant` (PG
+ *    schema-per-tenant or `tenant_id` partition key), `unsharded`.
+ *
+ * 2. **Bulk-write API** — {@link writeBatch} routes a batch of Things +
+ *    Actions through the adapter's cascade fast path. For PG, that's the
+ *    **CTE jsonb-bulk shape** proven by the substrate-write-probes
+ *    (91 ms p50 for 500 things + 499 actions on Neon HTTP — see
+ *    `docs/reviews/2026-05-05-cascade-poc-evaluation.md`). For DO SQLite,
+ *    the routing layer pins the shard and forwards the batch into the
+ *    per-cascade DO. For ClickHouse, JSONEachRow is the path.
+ *
+ * 3. **Read-back-during-traversal API** — {@link readShardLocal} performs a
+ *    point read against the same shard the batch was written to. Cascade
+ *    generation reads back just-written entities to inform the next
+ *    generation step; cross-shard reads on the hot path are explicitly
+ *    not supported.
+ *
+ * 4. **Pipelines fan-out hook** — a {@link AnalyticalEmitter} callback the
+ *    caller may pass to {@link writeBatch}. The cascade-write-strategy
+ *    invokes it post-commit so Stack B's dual-write
+ *    (DO SQLite local → Pipelines → Iceberg → ClickHouse) can be wired
+ *    later by `aip-0ypt` without changing this surface.
+ *
+ * ## Why a separate module
+ *
+ * The cascade orchestrator is long, has its own retry/validation/policy
+ * concerns, and needs swappable storage. Pulling the write-strategy
+ * primitive out keeps the orchestration module focused, lets us unit-test
+ * shard-key derivation independently of LLM calls, and keeps the
+ * provenance of the write shape (the substrate-write-probes verdict)
+ * documented in one place rather than scattered through orchestrator code.
+ *
+ * @see {@link ../docs/adr/0003-storage-strategy-pg-clickhouse-default.md}
+ * @see {@link ../docs/reviews/2026-05-05-cascade-poc-evaluation.md}
+ * @packageDocumentation
+ */
+import { getProviderCapabilities } from './db-provider-port.js';
+/**
+ * Built-in cascade sharding strategies.
+ *
+ * Each maps the abstract {@link ShardingModel} declared on a `DBProvider`
+ * to a concrete routing-key derivation. Adapters consult their adapter's
+ * declared sharding model via {@link getProviderCapabilities} when
+ * picking a default; callers can override.
+ *
+ * - {@link perCascade} — one shard per cascade. Default for
+ *   `do-sqlite` adapter (per ADR-0003 enabling pattern). Throws if
+ *   {@link CascadeShardContext.cascadeId} is missing.
+ * - {@link partitionedByTenant} — one shard per tenant. Default for
+ *   `pg+pgvector` adapter. Throws if {@link CascadeShardContext.tenantId}
+ *   is missing.
+ * - {@link unsharded} — single global shard. Default for `memory` and any
+ *   adapter that does not declare a sharding model. Always returns the
+ *   constant key `'__shared__'`.
+ */
+export const CascadeShardingStrategies = {
+    /**
+     * One shard per cascade. Stack B's enabling pattern: every active
+     * cascade gets its own DO (or its own PG partition / temp schema)
+     * giving full single-shard write throughput in parallel.
+     *
+     * @param defaultCascadeId - Fallback when the per-op context omits
+     *   `cascadeId`. Useful when the orchestrator has a stable cascade
+     *   scope but individual write batches don't restate it.
+     */
+    perCascade(defaultCascadeId) {
+        return (ctx) => {
+            const cascadeId = ctx.cascadeId ?? defaultCascadeId;
+            if (!cascadeId) {
+                throw new Error('CascadeShardingStrategies.perCascade: no cascadeId in context. ' +
+                    'Pass `cascadeId` on the CascadeShardContext, or supply a ' +
+                    'default via perCascade(defaultCascadeId).');
+            }
+            return {
+                key: `cascade:${cascadeId}`,
+                model: 'per-cascade',
+                context: { ...ctx, cascadeId },
+            };
+        };
+    },
+    /**
+     * One shard per tenant. The natural shape for multi-tenant Postgres
+     * (schema-per-tenant or `tenant_id` partition key). Many cascades
+     * within the same tenant share a partition; tenants are isolated.
+     *
+     * @param defaultTenantId - Fallback when the per-op context omits
+     *   `tenantId`.
+     */
+    partitionedByTenant(defaultTenantId) {
+        return (ctx) => {
+            const tenantId = ctx.tenantId ?? defaultTenantId;
+            if (!tenantId) {
+                throw new Error('CascadeShardingStrategies.partitionedByTenant: no tenantId in ' +
+                    'context. Pass `tenantId` on the CascadeShardContext, or supply ' +
+                    'a default via partitionedByTenant(defaultTenantId).');
+            }
+            return {
+                key: `tenant:${tenantId}`,
+                model: 'partitioned-by-tenant',
+                context: { ...ctx, tenantId },
+            };
+        };
+    },
+    /**
+     * Single global shard. Default for in-memory / dev / single small PG
+     * deployments. Cascade throughput hits the underlying adapter's
+     * single-writer ceiling.
+     */
+    unsharded() {
+        return (ctx) => ({
+            key: '__shared__',
+            model: 'unsharded',
+            context: { ...ctx },
+        });
+    },
+};
+/**
+ * The cascade write strategy primitive.
+ *
+ * Composes a `DBProvider` adapter with a sharding strategy and exposes
+ * the bulk-write + read-back surface the cascade orchestrator
+ * (`aip-8yal`) calls per traversal step. This module owns:
+ *
+ * - Routing-key derivation ({@link pickShard})
+ * - Bulk write via the adapter's cascade fast path ({@link writeBatch})
+ * - Local read-back from the same shard ({@link readShardLocal})
+ * - Analytical fan-out hook (post-commit; opt-in)
+ *
+ * It does NOT own:
+ *
+ * - LLM-driven generation (the orchestrator calls it before issuing batches)
+ * - Validation / policy / retry (the orchestrator wraps the strategy)
+ * - Pipelines→Iceberg dual-write semantics (`aip-0ypt`)
+ * - Cross-shard joins (out of scope per ADR-0003 hot-path constraint)
+ *
+ * @example
+ * ```ts
+ * import {
+ *   CascadeWriteStrategy,
+ *   createPostgresProvider,
+ * } from 'ai-database'
+ *
+ * const adapter = createPostgresProvider({ executor, namespace: 'tenant-9' })
+ * const strategy = new CascadeWriteStrategy({
+ *   adapter,
+ *   sharding: 'partitioned-by-tenant',
+ *   defaultTenantId: 'tenant-9',
+ * })
+ *
+ * const shard = strategy.pickShard({
+ *   rootEntity: { $id: 'fh-1', $type: 'FoundingHypothesis' },
+ *   tenantId: 'tenant-9',
+ * })
+ *
+ * await strategy.writeBatch(shard, {
+ *   things: [{ id: 'cust-1', type: 'Customer', data: { name: 'Acme' } }],
+ *   actions: [{ verb: 'placedBy', subject: 'order-1', object: 'cust-1', status: 'completed' }],
+ * })
+ * ```
+ */
+export class CascadeWriteStrategy {
+    adapter;
+    strategy;
+    maxBatchSize;
+    emitter;
+    constructor(options) {
+        this.adapter = options.adapter;
+        this.strategy = resolveShardingStrategy(options);
+        this.maxBatchSize = options.maxBatchSize ?? 1000;
+        this.emitter = options.analyticalEmitter;
+    }
+    /**
+     * Derive the {@link ShardRef} the next batch should land in. Pure —
+     * never touches the adapter.
+     *
+     * Throws when the active strategy needs context the caller didn't
+     * supply (e.g. `'per-cascade'` with no `cascadeId`).
+     */
+    pickShard(context) {
+        return this.strategy(context);
+    }
+    /**
+     * Bulk-commit a batch of Things + Actions to the shard.
+     *
+     * - When the adapter is {@link BulkCommitCapable}, the entire batch
+     *   travels in a single fast-path call — for PG that's the CTE
+     *   jsonb-bulk shape (91 ms p50 / 500 things on Neon HTTP), for CH
+     *   the JSONEachRow path.
+     * - When the adapter is not bulk-capable (in-memory, DO SQLite via
+     *   the current wire shape), the strategy falls back to per-op
+     *   `create()` + `relate()` calls. This still flows through the
+     *   shard-aware adapter so reads land on the same shard, but
+     *   throughput is the per-op ceiling.
+     * - Batches larger than {@link maxBatchSize} are split into rounds.
+     *   Rounds run sequentially within a single `writeBatch` call to
+     *   preserve write-order guarantees the orchestrator may rely on
+     *   (e.g. parents before children). Sibling parallelism is the
+     *   orchestrator's concern, not this primitive's.
+     *
+     * Post-commit, if an {@link AnalyticalEmitter} was configured, it is
+     * invoked once per chunk so Stack B's analytical fan-out can mirror
+     * the same batch into Pipelines→Iceberg. Emitter failures are logged
+     * and swallowed — they MUST NOT fail the cascade write.
+     */
+    async writeBatch(shard, batch) {
+        const things = batch.things ?? [];
+        const actions = batch.actions ?? [];
+        if (things.length === 0 && actions.length === 0) {
+            return { thingsInserted: 0, actionsInserted: 0, shard };
+        }
+        const boundAdapter = this.bindAdapterToShard(shard);
+        const chunks = chunkBatch({ things, actions }, this.maxBatchSize);
+        let thingsInserted = 0;
+        let actionsInserted = 0;
+        for (const chunk of chunks) {
+            const result = await this.writeChunk(boundAdapter, chunk);
+            thingsInserted += result.thingsInserted;
+            actionsInserted += result.actionsInserted;
+            // Post-commit fan-out hook for aip-0ypt. Failures are non-fatal —
+            // the cascade local commit is the source of truth for traversal.
+            if (this.emitter) {
+                try {
+                    await this.emitter({ shard, batch: chunk, result });
+                }
+                catch {
+                    // Analytical fan-out is best-effort; log site is the caller's
+                    // concern (we don't pull a logger dependency here).
+                }
+            }
+        }
+        return { thingsInserted, actionsInserted, shard };
+    }
+    /**
+     * Read a Thing back from the same shard the batch was written to.
+     *
+     * Cascade generation reads back just-written entities to inform the
+     * next traversal step (e.g. resolve a freshly-written `Customer`
+     * before generating its `Orders`). Cross-shard reads are explicitly
+     * not supported on the hot path per ADR-0003.
+     *
+     * Returns `null` if the entity is not in the shard. The caller may
+     * still attempt a cross-shard read via the unsharded adapter surface
+     * if needed for cold-path reconciliation.
+     */
+    async readShardLocal(shard, type, id) {
+        const boundAdapter = this.bindAdapterToShard(shard);
+        return boundAdapter.get(type, id);
+    }
+    /**
+     * Read a list of just-written entities from the shard. Wraps
+     * `adapter.list(type)` after binding the shard context.
+     *
+     * Use when the cascade needs to enumerate all of a type the current
+     * cascade has produced (e.g. all `OrderItem` for the current
+     * `Order`). For point reads, prefer {@link readShardLocal}.
+     */
+    async listShardLocal(shard, type, options) {
+        const boundAdapter = this.bindAdapterToShard(shard);
+        return boundAdapter.list(type, options);
+    }
+    // ===========================================================================
+    // Internal helpers
+    // ===========================================================================
+    /**
+     * Bind the adapter to the shard so subsequent ops route correctly.
+     *
+     * For DO SQLite, {@link DOSqliteAdapter.withContext} is used to pin
+     * the cascade/tenant id. For PG/CH, the `ns` column on the adapter
+     * already carries the partition key, so this is a no-op (return
+     * `this`).
+     */
+    bindAdapterToShard(shard) {
+        const bindable = this.adapter;
+        if (typeof bindable.withContext === 'function') {
+            return bindable.withContext({ ...shard.context });
+        }
+        return this.adapter;
+    }
+    /**
+     * Write a single chunk through the adapter's cascade fast path or
+     * the per-op fallback.
+     */
+    async writeChunk(adapter, chunk) {
+        const things = chunk.things ?? [];
+        const actions = chunk.actions ?? [];
+        const bulkCapable = adapter;
+        if (typeof bulkCapable.commitBatch === 'function') {
+            // PG / CH fast path. PG uses the CTE jsonb-bulk shape (proven by
+            // the substrate-write-probes); CH uses JSONEachRow. Both shapes
+            // are documented on the respective adapter.
+            return bulkCapable.commitBatch({
+                ...(things.length > 0 && { things }),
+                ...(actions.length > 0 && {
+                    actions: actions.map((a) => ({
+                        ...(a.id !== undefined && { id: a.id }),
+                        verb: a.verb,
+                        subject: a.subject,
+                        object: a.object,
+                        roles: a.roles,
+                        data: a.data,
+                        status: a.status,
+                    })),
+                }),
+            });
+        }
+        // Fallback: per-op writes. Used by DO SQLite (bulk path lives at the
+        // DO wire level — out of scope for this bead) and the in-memory
+        // adapter. Sequential within a chunk so writes appear in the order
+        // the orchestrator emitted them; parallelism is the orchestrator's
+        // concern.
+        let thingsInserted = 0;
+        for (const thing of things) {
+            try {
+                await adapter.create(thing.type, thing.id, thing.data);
+                thingsInserted += 1;
+            }
+            catch (err) {
+                // Best-effort idempotency: swallow already-exists errors so
+                // re-runs of a content-hashed cascade don't fail. Surface
+                // anything else.
+                if (!isAlreadyExistsError(err))
+                    throw err;
+            }
+        }
+        let actionsInserted = 0;
+        for (const action of actions) {
+            // Use recordAction when available (SVO surface); fall back to
+            // relate() if the adapter only exposes the structural surface.
+            const svo = adapter;
+            if (typeof svo.recordAction === 'function') {
+                await svo.recordAction({
+                    verb: action.verb,
+                    ...(action.subject !== undefined && { subject: action.subject }),
+                    ...(action.object !== undefined && { object: action.object }),
+                    ...(action.roles !== undefined && { roles: action.roles }),
+                    ...(action.data !== undefined && { data: action.data }),
+                    ...(action.status !== undefined && { status: action.status }),
+                });
+            }
+            else if (action.subject && action.object) {
+                // Best-effort fallback — the adapter doesn't speak SVO. We have
+                // no type information for relate(), which expects fromType /
+                // toType; we use the data fields if present, else a generic
+                // 'Thing' placeholder. Adapters in this position are dev-only
+                // (in-memory tests) so this is acceptable.
+                const fromType = action.data?.['fromType'] ?? 'Thing';
+                const toType = action.data?.['toType'] ?? 'Thing';
+                await adapter.relate(fromType, action.subject, action.verb, toType, action.object);
+            }
+            actionsInserted += 1;
+        }
+        return { thingsInserted, actionsInserted };
+    }
+}
+// =============================================================================
+// PG-specific bulk-write helper — the proven CTE jsonb-bulk shape
+// =============================================================================
+/**
+ * Stand-alone helper that emits the PG cascade-write SQL the
+ * substrate-write-probes proved out: a single CTE round-trip with
+ * bulk `VALUES (...), (...)` inserts and `ON CONFLICT DO NOTHING`.
+ *
+ * **This is the shape the canonical PG adapter's
+ * {@link PostgresProvider.commitBatch} uses.** The helper is exported so
+ * cascade orchestrators that bypass the adapter (e.g. running raw SQL
+ * for benchmarking) can still use the proven shape without re-deriving
+ * it. The adapter's `commitBatch` remains the recommended path.
+ *
+ * Returns the SQL text + ordered positional params. Things take 4
+ * columns: `(ns, id, type, data)`. Actions take 10 columns:
+ * `(ns, id, verb, subject, object, roles, data, status, created_at, completed_at)`.
+ *
+ * Why: documenting the shape in a stand-alone helper anchors the write
+ * shape to the substrate-write-probes evidence (91 ms p50 for 500 docs +
+ * 499 rels on Neon HTTP, sublinear scaling above N=100). Future schema
+ * changes that invalidate the column list will land here visibly.
+ *
+ * @internal Use {@link PostgresProvider.commitBatch} for production code.
+ */
+export function buildPgCommitBatchSql(input) {
+    const { schema, namespace, things, actions, now } = input;
+    if (things.length === 0 && actions.length === 0)
+        return null;
+    const thingCols = 4;
+    const actionCols = 10;
+    const thingOffset = things.length * thingCols;
+    const thingPlaceholders = things
+        .map((_, i) => {
+        const base = i * thingCols;
+        return `($${base + 1}, $${base + 2}, $${base + 3}, $${base + 4}::jsonb)`;
+    })
+        .join(', ');
+    const actionPlaceholders = actions
+        .map((_, i) => {
+        const base = thingOffset + i * actionCols;
+        return `($${base + 1}, $${base + 2}, $${base + 3}, $${base + 4}, $${base + 5}, $${base + 6}::jsonb, $${base + 7}::jsonb, $${base + 8}, $${base + 9}, $${base + 10})`;
+    })
+        .join(', ');
+    const params = [];
+    for (const t of things) {
+        params.push(namespace, t.id, t.type, JSON.stringify(t.data));
+    }
+    for (const a of actions) {
+        const status = a.status ?? 'pending';
+        const completedAt = status === 'completed' || status === 'failed' || status === 'cancelled' ? now : null;
+        params.push(namespace, a.id ?? generateId(), a.verb, a.subject ?? null, a.object ?? null, JSON.stringify(a.roles ?? {}), JSON.stringify(a.data ?? {}), status, now, completedAt);
+    }
+    const ctes = [];
+    if (things.length > 0) {
+        ctes.push(`inserted_things AS (
+        INSERT INTO ${schema}.things (ns, id, type, data) VALUES ${thingPlaceholders}
+        ON CONFLICT ON CONSTRAINT things_pk DO NOTHING
+        RETURNING 1
+      )`);
+    }
+    if (actions.length > 0) {
+        ctes.push(`inserted_actions AS (
+        INSERT INTO ${schema}.actions
+          (ns, id, verb, subject, object, roles, data, status, created_at, completed_at)
+        VALUES ${actionPlaceholders}
+        ON CONFLICT ON CONSTRAINT actions_pk DO NOTHING
+        RETURNING 1
+      )`);
+    }
+    const sql = `WITH ${ctes.join(', ')}
+    SELECT
+      ${things.length > 0 ? `(SELECT COUNT(*) FROM inserted_things)::int` : '0'} AS things_inserted,
+      ${actions.length > 0 ? `(SELECT COUNT(*) FROM inserted_actions)::int` : '0'} AS actions_inserted`;
+    return { sql, params };
+}
+// =============================================================================
+// DO SQLite shard-routing helper
+// =============================================================================
+/**
+ * Resolve the DO id name for a given shard from a Cloudflare DO
+ * namespace binding.
+ *
+ * The actual shard pinning happens inside `DOSqliteAdapter` —
+ * {@link DOSqliteAdapter.withContext} consumes the `ShardRef.context`
+ * when subsequent ops are issued, and the adapter's internal
+ * `resolveStub` calls `namespace.idFromName(...).` This helper exposes
+ * the same routing logic for callers that need to **manually** route a
+ * batch into a per-cascade DO without going through the adapter (e.g.
+ * direct fetch into a DO that hasn't been wrapped yet).
+ *
+ * For canonical use, prefer the adapter — `withContext(shard.context)`
+ * encapsulates this.
+ *
+ * @example
+ * ```ts
+ * import { resolveDOIdName, CascadeShardingStrategies } from 'ai-database'
+ *
+ * const strategy = CascadeShardingStrategies.perCascade()
+ * const shard = strategy({ cascadeId: 'abc' })
+ * const idName = resolveDOIdName(shard) // 'cascade:abc'
+ * const id = env.DATABASE.idFromName(idName)
+ * const stub = env.DATABASE.get(id)
+ * await stub.fetch(...)
+ * ```
+ */
+export function resolveDOIdName(shard) {
+    return shard.key;
+}
+// =============================================================================
+// Helpers — chunking, error classification, id generation, strategy resolution
+// =============================================================================
+/**
+ * Split a batch into chunks no larger than `maxBatchSize` rows
+ * (Things + Actions counted together).
+ *
+ * The substrate-write-probes verdict shows sublinear scaling above N=100
+ * for the CTE shape — a single round-trip carrying 500 things + 499 rels
+ * lands in 91 ms p50. We default to 1000 rows/chunk in the strategy;
+ * callers can override via {@link CascadeWriteStrategyOptions.maxBatchSize}.
+ *
+ * Things and Actions are kept together within a chunk so a parent +
+ * child + their relation can fit in one round-trip when the orchestrator
+ * emits them as one batch. When the chunk boundary falls inside a
+ * Thing/Action group the orchestrator built, callers should size their
+ * batches (or the `maxBatchSize`) to avoid splitting groups.
+ *
+ * @internal exported for tests.
+ */
+export function chunkBatch(batch, maxBatchSize) {
+    if (maxBatchSize <= 0) {
+        throw new Error('chunkBatch: maxBatchSize must be > 0');
+    }
+    const things = batch.things ?? [];
+    const actions = batch.actions ?? [];
+    const total = things.length + actions.length;
+    if (total <= maxBatchSize)
+        return [{ things, actions }];
+    const chunks = [];
+    let ti = 0;
+    let ai = 0;
+    while (ti < things.length || ai < actions.length) {
+        const remainingThings = things.length - ti;
+        const takeThings = Math.min(remainingThings, maxBatchSize);
+        const remaining = maxBatchSize - takeThings;
+        const takeActions = Math.min(actions.length - ai, remaining);
+        chunks.push({
+            things: things.slice(ti, ti + takeThings),
+            actions: actions.slice(ai, ai + takeActions),
+        });
+        ti += takeThings;
+        ai += takeActions;
+    }
+    return chunks;
+}
+/**
+ * Classify an error as the adapter's idempotent-conflict signal so
+ * per-op fallback writes can swallow re-runs.
+ */
+function isAlreadyExistsError(err) {
+    if (!err)
+        return false;
+    const msg = err instanceof Error ? err.message : String(err);
+    // Loose match — adapters use different wording. Cascade re-runs depend
+    // on content-hashed ids, so a true conflict is benign.
+    return /already exists|duplicate|unique constraint|conflict/i.test(msg);
+}
+/**
+ * Resolve the active sharding strategy from constructor options. Falls
+ * back to the adapter's declared {@link ShardingModel} when the caller
+ * didn't supply one.
+ */
+function resolveShardingStrategy(opts) {
+    const sharding = opts.sharding;
+    if (typeof sharding === 'function')
+        return sharding;
+    const declared = sharding ?? getProviderCapabilities(opts.adapter).shardingModel;
+    switch (declared) {
+        case 'per-cascade':
+            return CascadeShardingStrategies.perCascade(opts.defaultCascadeId);
+        case 'partitioned-by-tenant':
+            return CascadeShardingStrategies.partitionedByTenant(opts.defaultTenantId);
+        case 'unsharded':
+            return CascadeShardingStrategies.unsharded();
+        default:
+            // Custom / forward-compat shard models declared by future adapters
+            // fall back to unsharded; callers should pass an explicit strategy.
+            return CascadeShardingStrategies.unsharded();
+    }
+}
+function generateId() {
+    if (typeof crypto !== 'undefined' && typeof crypto.randomUUID === 'function') {
+        return crypto.randomUUID();
+    }
+    // Tests in environments without `crypto` get a deterministic prefix +
+    // timestamp; production paths always have crypto available.
+    return `cascade-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+}
+/**
+ * Convenience factory.
+ *
+ * @example
+ * ```ts
+ * import {
+ *   createCascadeWriteStrategy,
+ *   createPostgresProvider,
+ * } from 'ai-database'
+ *
+ * const adapter = createPostgresProvider({ executor, namespace: 't9' })
+ * const strategy = createCascadeWriteStrategy({
+ *   adapter,
+ *   sharding: 'partitioned-by-tenant',
+ *   defaultTenantId: 't9',
+ * })
+ * ```
+ */
+export function createCascadeWriteStrategy(options) {
+    return new CascadeWriteStrategy(options);
+}
+//# sourceMappingURL=cascade-write-strategy.js.map

package/dist/cascade-write-strategy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cascade-write-strategy.js","sourceRoot":"","sources":["../src/cascade-write-strategy.ts"],"names":[],"mappings":"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"}