@assemora/database 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * `@assemora/database` — the neutral contract between the data layer and a database.
+ *
+ * It owns the Query AST (SPEC.md §30), the adapter interface (SPEC.md §31) and the
+ * schema diff a migration generator works from (SPEC.md §34), and nothing in it is
+ * specific to any engine. `@assemora/database-postgres` implements the contract with
+ * Drizzle inside; the in-memory adapter here implements the same contract for tests
+ * and for the phases where PostgreSQL does not exist yet.
+ */
+export type { ColumnDescriptor, ColumnType, DatabaseAdapter, DatabaseContext, DatabaseSchema, RelationDescriptor, RelationKind, TableDescriptor, } from './adapter.js';
+export { LOCALE_COLUMN, TRANSLATION_OF_COLUMN, UNSPECIFIED_LOCALE } from './adapter.js';
+export { isSchemaNotApplied, SCHEMA_NOT_APPLIED, schemaNotApplied, } from './errors.js';
+export { joinTableDescriptor, type PivotAddress, pivotAddress, withJoinTables, } from './join-table.js';
+export { createMemoryAdapter, type MemoryAdapter, type Row } from './memory.js';
+export { type Combinator, type Comparison, type ComparisonOperator, type Condition, type ConditionGroup, comparison, emptyQuery, group, type JsonComparison, jsonContains, jsonEquals, jsonLike, type Order, orComparison, type QueryAst, type QueryOperation, type RelationLoad, type SortDirection, } from './query-ast.js';
+export { type ChangeRisk, type ColumnAdded, type ColumnEnumChanged, type ColumnNullabilityChanged, type ColumnRemoved, type ColumnTypeChanged, type ColumnUniquenessChanged, describeChange, diffSchema, type ForeignKeyAdded, type ForeignKeyRemoved, type IndexAdded, type IndexRemoved, isDestructive, mayFailOnExistingRows, type PrimaryKeyMoved, type SchemaChange, type SchemaDiff, type TableAdded, type TableRemoved, } from './schema-diff.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,YAAY,EACV,gBAAgB,EAChB,UAAU,EACV,eAAe,EACf,eAAe,EACf,cAAc,EACd,kBAAkB,EAClB,YAAY,EACZ,eAAe,GAChB,MAAM,cAAc,CAAA;AACrB,OAAO,EAAE,aAAa,EAAE,qBAAqB,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAA;AACvF,OAAO,EACL,kBAAkB,EAClB,kBAAkB,EAClB,gBAAgB,GACjB,MAAM,aAAa,CAAA;AACpB,OAAO,EACL,mBAAmB,EACnB,KAAK,YAAY,EACjB,YAAY,EACZ,cAAc,GACf,MAAM,iBAAiB,CAAA;AACxB,OAAO,EAAE,mBAAmB,EAAE,KAAK,aAAa,EAAE,KAAK,GAAG,EAAE,MAAM,aAAa,CAAA;AAC/E,OAAO,EACL,KAAK,UAAU,EACf,KAAK,UAAU,EACf,KAAK,kBAAkB,EACvB,KAAK,SAAS,EACd,KAAK,cAAc,EACnB,UAAU,EACV,UAAU,EACV,KAAK,EACL,KAAK,cAAc,EACnB,YAAY,EACZ,UAAU,EACV,QAAQ,EACR,KAAK,KAAK,EACV,YAAY,EACZ,KAAK,QAAQ,EACb,KAAK,cAAc,EACnB,KAAK,YAAY,EACjB,KAAK,aAAa,GACnB,MAAM,gBAAgB,CAAA;AACvB,OAAO,EACL,KAAK,UAAU,EACf,KAAK,WAAW,EAChB,KAAK,iBAAiB,EACtB,KAAK,wBAAwB,EAC7B,KAAK,aAAa,EAClB,KAAK,iBAAiB,EACtB,KAAK,uBAAuB,EAC5B,cAAc,EACd,UAAU,EACV,KAAK,eAAe,EACpB,KAAK,iBAAiB,EACtB,KAAK,UAAU,EACf,KAAK,YAAY,EACjB,aAAa,EACb,qBAAqB,EACrB,KAAK,eAAe,EACpB,KAAK,YAAY,EACjB,KAAK,UAAU,EACf,KAAK,UAAU,EACf,KAAK,YAAY,GAClB,MAAM,kBAAkB,CAAA"}

package/dist/index.js

@@ -0,0 +1,16 @@
+/**
+ * `@assemora/database` — the neutral contract between the data layer and a database.
+ *
+ * It owns the Query AST (SPEC.md §30), the adapter interface (SPEC.md §31) and the
+ * schema diff a migration generator works from (SPEC.md §34), and nothing in it is
+ * specific to any engine. `@assemora/database-postgres` implements the contract with
+ * Drizzle inside; the in-memory adapter here implements the same contract for tests
+ * and for the phases where PostgreSQL does not exist yet.
+ */
+export { LOCALE_COLUMN, TRANSLATION_OF_COLUMN, UNSPECIFIED_LOCALE } from './adapter.js';
+export { isSchemaNotApplied, SCHEMA_NOT_APPLIED, schemaNotApplied, } from './errors.js';
+export { joinTableDescriptor, pivotAddress, withJoinTables, } from './join-table.js';
+export { createMemoryAdapter } from './memory.js';
+export { comparison, emptyQuery, group, jsonContains, jsonEquals, jsonLike, orComparison, } from './query-ast.js';
+export { describeChange, diffSchema, isDestructive, mayFailOnExistingRows, } from './schema-diff.js';
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAYH,OAAO,EAAE,aAAa,EAAE,qBAAqB,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAA;AACvF,OAAO,EACL,kBAAkB,EAClB,kBAAkB,EAClB,gBAAgB,GACjB,MAAM,aAAa,CAAA;AACpB,OAAO,EACL,mBAAmB,EAEnB,YAAY,EACZ,cAAc,GACf,MAAM,iBAAiB,CAAA;AACxB,OAAO,EAAE,mBAAmB,EAAgC,MAAM,aAAa,CAAA;AAC/E,OAAO,EAML,UAAU,EACV,UAAU,EACV,KAAK,EAEL,YAAY,EACZ,UAAU,EACV,QAAQ,EAER,YAAY,GAKb,MAAM,gBAAgB,CAAA;AACvB,OAAO,EAQL,cAAc,EACd,UAAU,EAKV,aAAa,EACb,qBAAqB,GAMtB,MAAM,kBAAkB,CAAA"}

package/dist/join-table.d.ts

@@ -0,0 +1,66 @@
+import type { RelationDescriptor, TableDescriptor } from './adapter.js';
+/**
+ * The join table a `belongsToMany` is stored in (SPEC.md §23).
+ *
+ * Named by `through` when the relation declares one, and by the two table names
+ * otherwise — sorted, so both sides of a mutual relation name the same table.
+ *
+ * ```ts
+ * joinTableDescriptor(User.descriptor, rolesRelation, Role.descriptor)
+ * // { name: 'roles_users', columns: [roleId, userId], uniqueTogether: [['roleId', 'userId']] }
+ * ```
+ */
+export declare const joinTableDescriptor: (owner: TableDescriptor, relation: RelationDescriptor, target?: TableDescriptor) => TableDescriptor;
+/**
+ * Where one row's links live, and what identifies them.
+ *
+ * Everything the pivot verbs of SPEC.md §24 need, and nothing an adapter has to learn:
+ * `attach` is an insert of the two columns, `detach` a delete of the two conditions,
+ * `sync` both inside one transaction — all of it ordinary Query AST.
+ */
+export type PivotAddress = {
+    /** The join table, ready to be handed to `DatabaseContext.table`. */
+    readonly table: TableDescriptor;
+    /** The column holding the owner's key. */
+    readonly ownerColumn: string;
+    /** The column holding the related row's key. */
+    readonly relatedColumn: string;
+    /** What the owner's row stores in the key the link points at. */
+    readonly ownerValue: unknown;
+};
+/**
+ * Addresses the join table for one row (SPEC.md §24).
+ *
+ * ```ts
+ * const pivot = pivotAddress(User.descriptor, roles, user.toJSON(), Role.descriptor)
+ *
+ * await adapter.execute(
+ *   {
+ *     ...emptyQuery(pivot.table.name, 'insert'),
+ *     data: { [pivot.ownerColumn]: pivot.ownerValue, [pivot.relatedColumn]: roleId },
+ *   },
+ *   { table: pivot.table },
+ * )
+ * ```
+ */
+export declare const pivotAddress: (owner: TableDescriptor, relation: RelationDescriptor, row: Readonly<Record<string, unknown>>, target?: TableDescriptor) => PivotAddress;
+/**
+ * The tables a schema really has: the declared ones, plus a join table per
+ * `belongsToMany` (SPEC.md §23, §34).
+ *
+ * Idempotent, and that is what makes it safe to call anywhere. A join table declares
+ * no `belongsToMany` of its own, so expanding an expanded schema adds nothing — a
+ * snapshot that already holds the join table compares clean against a registry that
+ * derives it.
+ *
+ * A model declared for a table a relation derives is refused, rather than allowed to
+ * win. Only the DDL would ever read it: the pivot verbs of SPEC.md §24 write the two
+ * derived columns and nothing else, so a declared pivot carrying a surrogate key or a
+ * `joinedAt` is a table `attach` cannot fill, and one carrying exactly the two keys is
+ * a second descriptor for a name the adapter already builds. Keeping the declaration
+ * for the DDL and deriving the writes is the disagreement this whole file exists to
+ * prevent — a pivot with columns of its own is a model like any other, and it is
+ * declared with two `belongsTo` relations rather than with `through`.
+ */
+export declare const withJoinTables: (tables: readonly TableDescriptor[]) => readonly TableDescriptor[];
+//# sourceMappingURL=join-table.d.ts.map

package/dist/join-table.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"join-table.d.ts","sourceRoot":"","sources":["../src/join-table.ts"],"names":[],"mappings":"AAmBA,OAAO,KAAK,EAGV,kBAAkB,EAClB,eAAe,EAChB,MAAM,cAAc,CAAA;AAmKrB;;;;;;;;;;GAUG;AACH,eAAO,MAAM,mBAAmB,UACvB,eAAe,YACZ,kBAAkB,WACnB,eAAe,KACvB,eAAwF,CAAA;AAE3F;;;;;;GAMG;AACH,MAAM,MAAM,YAAY,GAAG;IACzB,qEAAqE;IACrE,QAAQ,CAAC,KAAK,EAAE,eAAe,CAAA;IAC/B,0CAA0C;IAC1C,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAA;IAC5B,gDAAgD;IAChD,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAA;IAC9B,iEAAiE;IACjE,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAA;CAC7B,CAAA;AAED;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,YAAY,UAChB,eAAe,YACZ,kBAAkB,OACvB,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,WAC7B,eAAe,KACvB,YAoBF,CAAA;AAoCD;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,cAAc,WAAY,SAAS,eAAe,EAAE,KAAG,SAAS,eAAe,EAyD3F,CAAA"}

package/dist/join-table.js

@@ -0,0 +1,265 @@
+/**
+ * Join tables (SPEC.md §23, §24).
+ *
+ * `belongsToMany` is the one relation that stores nothing on either table it links:
+ * the pairs live in a third table no model declares. Three subsystems need that
+ * table — the data layer writes the pivot verbs to it, the DDL creates it, the diff
+ * notices it arriving — and deriving it three times is how they come to disagree. So
+ * it is derived once, here, as an ordinary `TableDescriptor`. Everything that already
+ * knows what to do with a table knows what to do with this one, and a pivot write is
+ * an ordinary insert through the Query AST rather than an operation of its own
+ * (ADR-0001, ADR-0013).
+ *
+ * The derivation is symmetric on purpose. Both sides of a mutual `belongsToMany`
+ * derive the same name, the same two columns in the same order and the same foreign
+ * keys, so a schema holding `users.roles` and `roles.users` holds one join table
+ * rather than two that disagree.
+ */
+import { AssemoraError } from '@assemora/core';
+/**
+ * `users` → `userId`. Crude on purpose, and the same rule a `hasMany` foreign key
+ * follows, so a join column is named the way every other reference to that table is.
+ * `foreignPivotKey` and `relatedPivotKey` are there for where it does not fit.
+ */
+const pivotColumnFor = (table) => `${table.endsWith('s') ? table.slice(0, -1) : table}Id`;
+/**
+ * What a key column holds when the descriptor holding it is not to hand.
+ *
+ * `model()` names `id` as the primary key of a table that marks no column primary,
+ * and a primary key nobody typed is a `uuid` in every starter (SPEC.md §17).
+ */
+const DEFAULT_KEY = 'id';
+const DEFAULT_KEY_TYPE = 'uuid';
+const typeOfKey = (table, key) => table?.columns.find((column) => column.name === key)?.type ?? DEFAULT_KEY_TYPE;
+const assertBelongsToMany = (owner, relation) => {
+    if (relation.kind === 'belongsToMany')
+        return;
+    throw new AssemoraError('NOT_A_JOIN_TABLE', `"${owner.name}.${relation.name}" is a ${relation.kind} relation, and only belongsToMany is stored in a join table`, { status: 500 });
+};
+/**
+ * The two ends of the link, in the order they were declared in.
+ *
+ * `ownerKey` means here what it means for every other kind — the column on the owner
+ * that the reference points at — so the only thing `belongsToMany` needs of its own is
+ * a name for each of the two join columns.
+ *
+ * `target` is optional because a relation names the other table but does not carry it.
+ * Passing it is what makes the related column take the type of the key it holds;
+ * `withJoinTables` always does, and a caller with one table in its hand gets the
+ * default rather than an error.
+ */
+const sidesOf = (owner, relation, target) => {
+    assertBelongsToMany(owner, relation);
+    const relatedKey = target?.primaryKey ?? DEFAULT_KEY;
+    const sides = {
+        owner: {
+            table: owner.name,
+            column: relation.foreignPivotKey ?? pivotColumnFor(owner.name),
+            key: relation.ownerKey,
+            type: typeOfKey(owner, relation.ownerKey),
+        },
+        related: {
+            table: relation.target,
+            column: relation.relatedPivotKey ?? pivotColumnFor(relation.target),
+            key: relatedKey,
+            type: typeOfKey(target, relatedKey),
+        },
+    };
+    if (sides.owner.column === sides.related.column) {
+        throw new AssemoraError('INVALID_JOIN_TABLE', `The join table for "${owner.name}.${relation.name}" would hold two columns named "${sides.owner.column}", ` +
+            'so the two sides of the link cannot be told apart. Name them with `foreignPivotKey` and ' +
+            '`relatedPivotKey` — a relation whose target is its own table always has to.', { status: 500 });
+    }
+    return sides;
+};
+/**
+ * The two ends in a canonical order, which is what makes the derivation symmetric.
+ *
+ * Sorted by table name, and by column name where one table links to itself: both
+ * declarations of a mutual relation then produce the identical descriptor, down to the
+ * order of the columns, so `withJoinTables` can recognise them as one table instead of
+ * reporting two.
+ *
+ * Compared by code point rather than by `localeCompare`, because the name this decides
+ * is written into a migration and read back on another machine. A locale is not a
+ * shared fact, and one that orders two tables the other way round would rename a table
+ * that nobody touched.
+ */
+const ordered = (first, second) => {
+    const inOrder = first.table === second.table ? first.column <= second.column : first.table < second.table;
+    return inOrder ? [first, second] : [second, first];
+};
+const pivotColumn = (side) => ({
+    name: side.column,
+    type: side.type,
+    isPrimary: false,
+    isNullable: false,
+    // Neither key is unique on its own — a user holds many roles and a role many users.
+    // Only the pair is, and `uniqueTogether` on the table is what says so.
+    isUnique: false,
+    // The foreign key below brings the index with it: a generator indexes the
+    // referencing side of every relation it creates, and a second index on the same
+    // column would only cost writes.
+    isIndexed: false,
+    hasDefault: false,
+});
+/**
+ * A `belongsTo` per side, so the join table is created with real foreign keys.
+ *
+ * Without them a deleted role leaves its pivot rows behind, and the next load of
+ * `user.roles` returns ids pointing at nothing. It also means every generator that
+ * already turns a `belongsTo` into a constraint and an index needs nothing new.
+ *
+ * The relation is named after its column rather than after the table it points at: a
+ * table linked to itself has two sides with the same target, and a descriptor holding
+ * two relations of one name is one that nothing can address.
+ */
+const pivotRelation = (side) => ({
+    name: side.column,
+    kind: 'belongsTo',
+    target: side.table,
+    foreignKey: side.column,
+    ownerKey: side.key,
+});
+const describeJoinTable = (sides, through) => {
+    const [first, second] = ordered(sides.owner, sides.related);
+    return {
+        name: through ?? `${first.table}_${second.table}`,
+        // A join table has no key of its own: the pair is its identity, and `primaryKey`
+        // names a single column. Naming half the pair would tell a generator to make one
+        // side unique, which is the opposite of what a link table is for.
+        primaryKey: '',
+        columns: [pivotColumn(first), pivotColumn(second)],
+        relations: [pivotRelation(first), pivotRelation(second)],
+        uniqueTogether: [[first.column, second.column]],
+    };
+};
+/**
+ * The join table a `belongsToMany` is stored in (SPEC.md §23).
+ *
+ * Named by `through` when the relation declares one, and by the two table names
+ * otherwise — sorted, so both sides of a mutual relation name the same table.
+ *
+ * ```ts
+ * joinTableDescriptor(User.descriptor, rolesRelation, Role.descriptor)
+ * // { name: 'roles_users', columns: [roleId, userId], uniqueTogether: [['roleId', 'userId']] }
+ * ```
+ */
+export const joinTableDescriptor = (owner, relation, target) => describeJoinTable(sidesOf(owner, relation, target), relation.through);
+/**
+ * Addresses the join table for one row (SPEC.md §24).
+ *
+ * ```ts
+ * const pivot = pivotAddress(User.descriptor, roles, user.toJSON(), Role.descriptor)
+ *
+ * await adapter.execute(
+ *   {
+ *     ...emptyQuery(pivot.table.name, 'insert'),
+ *     data: { [pivot.ownerColumn]: pivot.ownerValue, [pivot.relatedColumn]: roleId },
+ *   },
+ *   { table: pivot.table },
+ * )
+ * ```
+ */
+export const pivotAddress = (owner, relation, row, target) => {
+    const sides = sidesOf(owner, relation, target);
+    const ownerValue = row[sides.owner.key];
+    // A link to a row that was never stored points at nothing, and inserting it writes a
+    // pivot row no read can ever join. Refusing here catches it once for every caller.
+    if (ownerValue === undefined || ownerValue === null) {
+        throw new AssemoraError('UNSAVED_RECORD', `Cannot address "${owner.name}.${relation.name}": the row has no ${sides.owner.key}. Save it first.`, { status: 409 });
+    }
+    return {
+        table: describeJoinTable(sides, relation.through),
+        ownerColumn: sides.owner.column,
+        relatedColumn: sides.related.column,
+        ownerValue,
+    };
+};
+/** What two derivations of one join table have to agree on, as one sentence. */
+const signatureOf = (table) => table.relations
+    .map((relation) => `${relation.foreignKey} -> ${relation.target}.${relation.ownerKey}`)
+    .join(', ');
+/**
+ * Everything about a table that is not its name, written down in a fixed order.
+ *
+ * Two descriptors that agree on this describe the identical table. Used to recognise
+ * a derived join table handed back to `withJoinTables` — the expansion is idempotent,
+ * so the join table it added last time arrives among the declared ones and must not be
+ * mistaken for a model of it.
+ */
+const shapeOf = (table) => [
+    table.primaryKey,
+    table.softDeleteColumn ?? '',
+    table.columns
+        .map((column) => `${column.name}:${column.type}:${column.isPrimary}:${column.isNullable}:` +
+        `${column.isUnique}:${column.isIndexed}:${column.hasDefault}`)
+        .join(','),
+    table.relations
+        .map((relation) => `${relation.name}:${relation.kind}:${relation.target}:${relation.foreignKey}:${relation.ownerKey}`)
+        .join(','),
+    (table.uniqueTogether ?? []).map((group) => group.join('+')).join(','),
+].join(' | ');
+/**
+ * The tables a schema really has: the declared ones, plus a join table per
+ * `belongsToMany` (SPEC.md §23, §34).
+ *
+ * Idempotent, and that is what makes it safe to call anywhere. A join table declares
+ * no `belongsToMany` of its own, so expanding an expanded schema adds nothing — a
+ * snapshot that already holds the join table compares clean against a registry that
+ * derives it.
+ *
+ * A model declared for a table a relation derives is refused, rather than allowed to
+ * win. Only the DDL would ever read it: the pivot verbs of SPEC.md §24 write the two
+ * derived columns and nothing else, so a declared pivot carrying a surrogate key or a
+ * `joinedAt` is a table `attach` cannot fill, and one carrying exactly the two keys is
+ * a second descriptor for a name the adapter already builds. Keeping the declaration
+ * for the DDL and deriving the writes is the disagreement this whole file exists to
+ * prevent — a pivot with columns of its own is a model like any other, and it is
+ * declared with two `belongsTo` relations rather than with `through`.
+ */
+export const withJoinTables = (tables) => {
+    const declared = new Map(tables.map((table) => [table.name, table]));
+    const derived = new Map();
+    for (const owner of tables) {
+        for (const relation of owner.relations) {
+            if (relation.kind !== 'belongsToMany')
+                continue;
+            const from = `${owner.name}.${relation.name}`;
+            const table = joinTableDescriptor(owner, relation, declared.get(relation.target));
+            const model = declared.get(table.name);
+            if (model !== undefined) {
+                // The expansion is idempotent, so the join table added by an earlier call
+                // arrives here among the declared tables. It is this derivation, not a model
+                // of it, and it is skipped exactly as it was before there was a rule.
+                if (shapeOf(model) === shapeOf(table))
+                    continue;
+                throw new AssemoraError('DECLARED_JOIN_TABLE', `"${from}" derives the join table "${table.name}", and a model declares it too. ` +
+                    'A derived pivot holds the two key columns and nothing else, which is all `attach`, ' +
+                    '`detach` and `sync` write — so a model of it is a table those verbs cannot fill. ' +
+                    'Either drop the model and let the relation derive the table, or keep the model, ' +
+                    'give it two `belongsTo` relations and address it as an ordinary table instead of ' +
+                    'through `belongsToMany`.', { status: 500 });
+            }
+            const existing = derived.get(table.name);
+            if (existing === undefined) {
+                derived.set(table.name, { table, from });
+                continue;
+            }
+            // Both sides of a mutual relation derive the same table from the same two model
+            // names, so a disagreement is always an override stated on one side only. Left
+            // alone it reaches the schema diff as two tables with one name, and is reported
+            // there as a duplicate descriptor rather than as the declaration that caused it.
+            if (signatureOf(existing.table) !== signatureOf(table)) {
+                throw new AssemoraError('CONFLICTING_JOIN_TABLE', `"${existing.from}" and "${from}" describe the join table "${table.name}" differently: ` +
+                    `(${signatureOf(existing.table)}) against (${signatureOf(table)}). ` +
+                    'Mirror `through`, `foreignPivotKey`, `relatedPivotKey` and `ownerKey` on both sides, ' +
+                    'or declare a model for the join table.', { status: 500 });
+            }
+        }
+    }
+    if (derived.size === 0)
+        return tables;
+    return [...tables, ...[...derived.values()].map((entry) => entry.table)];
+};
+//# sourceMappingURL=join-table.js.map

package/dist/join-table.js.map

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

package/dist/memory.d.ts

@@ -0,0 +1,22 @@
+import type { DatabaseAdapter } from './adapter.js';
+export type Row = Record<string, unknown>;
+export type MemoryAdapter = DatabaseAdapter & {
+    /** The rows a table currently holds, as stored. */
+    rows(table: string): readonly Row[];
+    seed(table: string, rows: readonly Row[]): void;
+    reset(): void;
+    /**
+     * Counters the tests read; not part of ordinary use.
+     *
+     * `scanCount()` is what `statementCount()` is on the PostgreSQL adapter: one pass
+     * over one table. A relation loaded in a batch costs a fixed number of passes
+     * however many rows it is loaded for, and one loaded row by row costs a pass per
+     * row — which is how SPEC.md §89 asks for an N+1 to be caught.
+     */
+    readonly diagnostics: {
+        scanCount(): number;
+        reset(): void;
+    };
+};
+export declare const createMemoryAdapter: (seed?: Readonly<Record<string, readonly Row[]>>) => MemoryAdapter;
+//# sourceMappingURL=memory.d.ts.map

package/dist/memory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory.d.ts","sourceRoot":"","sources":["../src/memory.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EACV,eAAe,EAKhB,MAAM,cAAc,CAAA;AAWrB,MAAM,MAAM,GAAG,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;AAEzC,MAAM,MAAM,aAAa,GAAG,eAAe,GAAG;IAC5C,mDAAmD;IACnD,IAAI,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,GAAG,EAAE,CAAA;IACnC,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,SAAS,GAAG,EAAE,GAAG,IAAI,CAAA;IAC/C,KAAK,IAAI,IAAI,CAAA;IACb;;;;;;;OAOG;IACH,QAAQ,CAAC,WAAW,EAAE;QACpB,SAAS,IAAI,MAAM,CAAA;QACnB,KAAK,IAAI,IAAI,CAAA;KACd,CAAA;CACF,CAAA;AA8ND,eAAO,MAAM,mBAAmB,UACxB,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,SAAS,GAAG,EAAE,CAAC,CAAC,KAC7C,aAyRF,CAAA"}