@zeroxsolutions/db 9.5.0 → 10.1.0

package/dist/utils/reads.d.ts

@@ -0,0 +1,30 @@
+import { type ExtractTablesWithRelations } from 'drizzle-orm';
+import type { VirtualField } from './filter.js';
+import type { ColumnName, OrderEntry } from './read.js';
+/** What holds for one table whichever read reaches it. */
+export interface TableReads<TColumn extends string = string, TContext = unknown> {
+    /** The order its rows load in as a relation that holds many; a relation's own `orderBy` replaces it. */
+    orderBy?: readonly OrderEntry<TColumn>[];
+    /** The filter and order names no column of it holds, each with the expression it becomes. */
+    virtual?: Readonly<Record<string, VirtualField<TContext>>>;
+}
+/**
+ * A context's reads, keyed by each table's EXPORT name in the schema. `TContext` types the request values its `virtual`
+ * names are decided against.
+ */
+export type Reads<TSchema extends Record<string, unknown> = Record<string, unknown>, TContext = unknown> = {
+    readonly [K in keyof ExtractTablesWithRelations<TSchema> & string]?: TableReads<ColumnName<TSchema, K>, TContext>;
+};
+/**
+ * Declares, once per context, what holds for each table whichever read reaches it: the order its rows load in as a
+ * relation, and its `virtual` filter and order names. Every repository of the context hands the same value to its base.
+ *
+ * `TContext` is the shape of the `context` a finder is handed for its `virtual` names; each receives it, or
+ * `undefined` where the caller handed none.
+ *
+ * @param schema - the schema barrel the repositories are typed by; each key is checked against it
+ * @throws Error at declaration on a key that is no table export of `schema`, or an order naming a column its table
+ *   does not hold
+ */
+export declare function defineReads<TSchema extends Record<string, unknown>, TContext = unknown>(schema: TSchema, reads: Reads<TSchema, TContext>): Reads<TSchema, TContext>;
+//# sourceMappingURL=reads.d.ts.map

package/dist/utils/reads.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reads.d.ts","sourceRoot":"","sources":["../../src/utils/reads.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,0BAA0B,EAChC,MAAM,aAAa,CAAC;AACrB,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAChD,OAAO,KAAK,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAExD,0DAA0D;AAC1D,MAAM,WAAW,UAAU,CAAC,OAAO,SAAS,MAAM,GAAG,MAAM,EAAE,QAAQ,GAAG,OAAO;IAC7E,wGAAwG;IACxG,OAAO,CAAC,EAAE,SAAS,UAAU,CAAC,OAAO,CAAC,EAAE,CAAC;IACzC,6FAA6F;IAC7F,OAAO,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;CAC5D;AAED;;;GAGG;AACH,MAAM,MAAM,KAAK,CAAC,OAAO,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,QAAQ,GAAG,OAAO,IAAI;IACzG,QAAQ,EAAE,CAAC,IAAI,MAAM,0BAA0B,CAAC,OAAO,CAAC,GAAG,MAAM,CAAC,CAAC,EAAE,UAAU,CAAC,UAAU,CAAC,OAAO,EAAE,CAAC,CAAC,EAAE,QAAQ,CAAC;CAClH,CAAC;AAEF;;;;;;;;;;GAUG;AACH,wBAAgB,WAAW,CAAC,OAAO,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,QAAQ,GAAG,OAAO,EACrF,MAAM,EAAE,OAAO,EACf,KAAK,EAAE,KAAK,CAAC,OAAO,EAAE,QAAQ,CAAC,GAC9B,KAAK,CAAC,OAAO,EAAE,QAAQ,CAAC,CAY1B"}

package/dist/utils/reads.js

@@ -0,0 +1,26 @@
+import { createTableRelationsHelpers, extractTablesRelationalConfig, } from 'drizzle-orm';
+/**
+ * Declares, once per context, what holds for each table whichever read reaches it: the order its rows load in as a
+ * relation, and its `virtual` filter and order names. Every repository of the context hands the same value to its base.
+ *
+ * `TContext` is the shape of the `context` a finder is handed for its `virtual` names; each receives it, or
+ * `undefined` where the caller handed none.
+ *
+ * @param schema - the schema barrel the repositories are typed by; each key is checked against it
+ * @throws Error at declaration on a key that is no table export of `schema`, or an order naming a column its table
+ *   does not hold
+ */
+export function defineReads(schema, reads) {
+    const { tables } = extractTablesRelationalConfig(schema, createTableRelationsHelpers);
+    for (const [key, declared] of Object.entries(reads)) {
+        const table = Object.hasOwn(tables, key) ? tables[key] : undefined;
+        if (!table)
+            throw new Error(`"${key}" is no table export of the schema.`);
+        for (const entry of declared?.orderBy ?? []) {
+            if (!Object.hasOwn(table.columns, entry.field)) {
+                throw new Error(`"${key}" holds no column "${entry.field}" to order by.`);
+            }
+        }
+    }
+    return reads;
+}

package/dist/utils/relationships.d.ts

@@ -1,14 +1,17 @@
 import { type ExtractTablesWithRelations } from 'drizzle-orm';
-/** The relation names a schema declares on one table, as the map `permitsFor` takes for its relationship filters. */
-export type RelationshipsOf<TSchema extends Record<string, unknown>, K extends keyof ExtractTablesWithRelations<TSchema>> = {
-    readonly [R in keyof ExtractTablesWithRelations<TSchema>[K]['relations'] & string]: Record<never, never>;
+import type { RelationTarget } from '@zeroxsolutions/query';
+/** The relations a schema declares on one table, keyed by name, each with the type it reaches. */
+export type RelationsOf<TSchema extends Record<string, unknown>, K extends keyof ExtractTablesWithRelations<TSchema>> = {
+    readonly [R in keyof ExtractTablesWithRelations<TSchema>[K]['relations'] & string]: RelationTarget;
 };
 /**
- * The relations `schema` declares on the table exported as `table`, read the way `drizzle({ schema })` reads them, so a
- * relation added to the schema is a relationship a permit list can name without a second list to edit.
+ * The relations `schema` declares on the table exported as `table`, read the way `drizzle({ schema })` reads them: each
+ * with the type its fieldset is keyed by (its table's SQL name), its primary key, and its own relations, read when a
+ * path walks into them. A permit list names its relationships off it, so a relation added to the schema is one a
+ * permit list can name without a second list to edit.
  *
  * @param table - the table's EXPORT name in `schema`, not its SQL name
  * @throws Error when `table` is no table export of `schema`
  */
-export declare function relationshipsOf<TSchema extends Record<string, unknown>, K extends keyof ExtractTablesWithRelations<TSchema> & string>(schema: TSchema, table: K): RelationshipsOf<TSchema, K>;
+export declare function relationsOf<TSchema extends Record<string, unknown>, K extends keyof ExtractTablesWithRelations<TSchema> & string>(schema: TSchema, table: K): RelationsOf<TSchema, K>;
 //# sourceMappingURL=relationships.d.ts.map

package/dist/utils/relationships.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"relationships.d.ts","sourceRoot":"","sources":["../../src/utils/relationships.ts"],"names":[],"mappings":"AAAA,OAAO,EAA8D,KAAK,0BAA0B,EAAE,MAAM,aAAa,CAAC;AAE1H,qHAAqH;AACrH,MAAM,MAAM,eAAe,CACzB,OAAO,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACvC,CAAC,SAAS,MAAM,0BAA0B,CAAC,OAAO,CAAC,IACjD;IAAE,QAAQ,EAAE,CAAC,IAAI,MAAM,0BAA0B,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,WAAW,CAAC,GAAG,MAAM,GAAG,MAAM,CAAC,KAAK,EAAE,KAAK,CAAC;CAAE,CAAC;AAEjH;;;;;;GAMG;AACH,wBAAgB,eAAe,CAC7B,OAAO,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACvC,CAAC,SAAS,MAAM,0BAA0B,CAAC,OAAO,CAAC,GAAG,MAAM,EAC5D,MAAM,EAAE,OAAO,EAAE,KAAK,EAAE,CAAC,GAAG,eAAe,CAAC,OAAO,EAAE,CAAC,CAAC,CAKxD"}
+{"version":3,"file":"relationships.d.ts","sourceRoot":"","sources":["../../src/utils/relationships.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,0BAA0B,EAChC,MAAM,aAAa,CAAC;AACrB,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAG5D,kGAAkG;AAClG,MAAM,MAAM,WAAW,CACrB,OAAO,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACvC,CAAC,SAAS,MAAM,0BAA0B,CAAC,OAAO,CAAC,IACjD;IAAE,QAAQ,EAAE,CAAC,IAAI,MAAM,0BAA0B,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,WAAW,CAAC,GAAG,MAAM,GAAG,cAAc;CAAE,CAAC;AAE3G;;;;;;;;GAQG;AACH,wBAAgB,WAAW,CACzB,OAAO,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACvC,CAAC,SAAS,MAAM,0BAA0B,CAAC,OAAO,CAAC,GAAG,MAAM,EAC5D,MAAM,EAAE,OAAO,EAAE,KAAK,EAAE,CAAC,GAAG,WAAW,CAAC,OAAO,EAAE,CAAC,CAAC,CAwBpD"}

package/dist/utils/relationships.js

@@ -1,15 +1,33 @@
-import { createTableRelationsHelpers, extractTablesRelationalConfig } from 'drizzle-orm';
+import { createTableRelationsHelpers, extractTablesRelationalConfig, getTableUniqueName, } from 'drizzle-orm';
+import { primaryKeyOf } from './read.js';
 /**
- * The relations `schema` declares on the table exported as `table`, read the way `drizzle({ schema })` reads them, so a
- * relation added to the schema is a relationship a permit list can name without a second list to edit.
+ * The relations `schema` declares on the table exported as `table`, read the way `drizzle({ schema })` reads them: each
+ * with the type its fieldset is keyed by (its table's SQL name), its primary key, and its own relations, read when a
+ * path walks into them. A permit list names its relationships off it, so a relation added to the schema is one a
+ * permit list can name without a second list to edit.
  *
  * @param table - the table's EXPORT name in `schema`, not its SQL name
  * @throws Error when `table` is no table export of `schema`
  */
-export function relationshipsOf(schema, table) {
-    const { tables } = extractTablesRelationalConfig(schema, createTableRelationsHelpers);
-    const config = Object.hasOwn(tables, table) ? tables[table] : undefined;
-    if (!config)
+export function relationsOf(schema, table) {
+    const { tables, tableNamesMap } = extractTablesRelationalConfig(schema, createTableRelationsHelpers);
+    if (!Object.hasOwn(tables, table))
         throw new Error(`"${table}" is no table export of the schema.`);
-    return Object.fromEntries(Object.keys(config.relations).map((name) => [name, {}]));
+    const relationsAt = (key) => Object.fromEntries(Object.entries(tables[key]?.relations ?? {}).map(([name, relation]) => {
+        const target = tableNamesMap[getTableUniqueName(relation.referencedTable)] ?? relation.referencedTableName;
+        return [name, targetAt(target)];
+    }));
+    // `relations` is a getter: a schema's relations come back to the tables they left, so building them eagerly
+    // would never end.
+    const targetAt = (key) => {
+        const config = tables[key];
+        return {
+            type: config?.dbName ?? key,
+            primaryKey: config ? primaryKeyOf(config) : [],
+            get relations() {
+                return relationsAt(key);
+            },
+        };
+    };
+    return relationsAt(table);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zeroxsolutions/db",
-  "version": "9.5.0",
+  "version": "10.1.0",
   "description": "Generic Drizzle toolkit - the id column and audit timestamps a table takes, a base repository, the unit-of-work and transactional outbox impls, and the filter/sort/pagination query helpers, for PostgreSQL (postgres-js) and Cloudflare D1; ships no domain schema. Shared across ZeroXSolutions services.",
   "private": false,
   "type": "module",
@@ -42,7 +42,7 @@
   "dependencies": {
     "tslib": "^2.3.0",
     "uuid": "^14.0.1",
-    "@zeroxsolutions/query": "0.7.3",
+    "@zeroxsolutions/query": "0.7.4",
     "@zeroxsolutions/cosmic": "0.3.4"
   },
   "peerDependencies": {
@@ -69,5 +69,10 @@
     "drizzle-orm": "^0.45.1",
     "postgres": "^3.4.9",
     "zod": "^4.3.6"
+  },
+  "nx": {
+    "targets": {
+      "lint-deps": {}
+    }
   }
 }

package/dist/utils/assert-queryable-fields.d.ts

@@ -1,27 +0,0 @@
-import type { GuardedCollectionQuery } from '@zeroxsolutions/query';
-import type { FilterValue, QueryableFields } from './filter.js';
-/** A `filter` targeted a field outside the entity's filterable whitelist. */
-export declare class InvalidQueryFilter extends Error {
-    constructor(field: string);
-}
-/** A `sort` targeted a field outside the entity's sortable whitelist. */
-export declare class InvalidQuerySort extends Error {
-    constructor(field: string);
-}
-/**
- * Rejects a `filter`/`sort` on any field outside a listable entity's {@link QueryableFields} whitelist,
- * so a client can never filter or order by a hidden column. A repository finder calls this before
- * building SQL.
- *
- * @param query - the parsed wire query, read for its `filter` / `sort` (a no-op when `undefined`)
- * @param resolved - the names a resolver answers, which no row key could list
- * @throws {@link InvalidQueryFilter} naming the first filtered field outside `allow.filterable` and
- *   `resolved.filterable`
- * @throws {@link InvalidQuerySort} naming the first sorted field outside `allow.sortable` and
- *   `resolved.sortable`
- */
-export declare function assertQueryableFields<TSelect>(query: Partial<Pick<GuardedCollectionQuery<FilterValue>, 'filter' | 'sort'>> | undefined, allow: QueryableFields<TSelect>, resolved?: {
-    filterable?: readonly string[];
-    sortable?: readonly string[];
-}): void;
-//# sourceMappingURL=assert-queryable-fields.d.ts.map

package/dist/utils/assert-queryable-fields.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"assert-queryable-fields.d.ts","sourceRoot":"","sources":["../../src/utils/assert-queryable-fields.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,uBAAuB,CAAC;AACpE,OAAO,KAAK,EAAc,WAAW,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAG5E,6EAA6E;AAC7E,qBAAa,kBAAmB,SAAQ,KAAK;gBAC/B,KAAK,EAAE,MAAM;CAG1B;AAED,yEAAyE;AACzE,qBAAa,gBAAiB,SAAQ,KAAK;gBAC7B,KAAK,EAAE,MAAM;CAG1B;AAaD;;;;;;;;;;;GAWG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAC3C,KAAK,EAAE,OAAO,CAAC,IAAI,CAAC,sBAAsB,CAAC,WAAW,CAAC,EAAE,QAAQ,GAAG,MAAM,CAAC,CAAC,GAAG,SAAS,EACxF,KAAK,EAAE,eAAe,CAAC,OAAO,CAAC,EAC/B,QAAQ,GAAE;IAAE,UAAU,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAAC,QAAQ,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;CAAO,GAC9E,IAAI,CAUN"}

package/dist/utils/assert-queryable-fields.js

@@ -1,47 +0,0 @@
-import { isFilterGroup } from './filter.js';
-/** A `filter` targeted a field outside the entity's filterable whitelist. */
-export class InvalidQueryFilter extends Error {
-    constructor(field) {
-        super(`Filtering by "${field}" is not supported.`);
-    }
-}
-/** A `sort` targeted a field outside the entity's sortable whitelist. */
-export class InvalidQuerySort extends Error {
-    constructor(field) {
-        super(`Sorting by "${field}" is not supported.`);
-    }
-}
-/** Walks the tree so a condition nested in a group is checked too, not just the root nodes. */
-function assertFilterNodes(nodes, filterable) {
-    for (const node of nodes) {
-        if (isFilterGroup(node)) {
-            assertFilterNodes(node.children, filterable);
-        }
-        else if (!filterable.includes(node.field)) {
-            throw new InvalidQueryFilter(node.field);
-        }
-    }
-}
-/**
- * Rejects a `filter`/`sort` on any field outside a listable entity's {@link QueryableFields} whitelist,
- * so a client can never filter or order by a hidden column. A repository finder calls this before
- * building SQL.
- *
- * @param query - the parsed wire query, read for its `filter` / `sort` (a no-op when `undefined`)
- * @param resolved - the names a resolver answers, which no row key could list
- * @throws {@link InvalidQueryFilter} naming the first filtered field outside `allow.filterable` and
- *   `resolved.filterable`
- * @throws {@link InvalidQuerySort} naming the first sorted field outside `allow.sortable` and
- *   `resolved.sortable`
- */
-export function assertQueryableFields(query, allow, resolved = {}) {
-    // Widened to `string`: the membership check runs against client-supplied names, not keys of TSelect.
-    const filterable = [...allow.filterable, ...(resolved.filterable ?? [])];
-    const sortable = [...allow.sortable, ...(resolved.sortable ?? [])];
-    assertFilterNodes(query?.filter ?? [], filterable);
-    for (const order of query?.sort ?? []) {
-        if (!sortable.includes(order.field)) {
-            throw new InvalidQuerySort(order.field);
-        }
-    }
-}

package/dist/utils/constants.d.ts

@@ -1,7 +0,0 @@
-/** Hard cap on a page's row count - a larger `limit` is silently clamped to this, not rejected. */
-export declare const MAX_PAGE_SIZE = 100;
-/** The offset applied when a query omits `offset` - starts at the first row. */
-export declare const DEFAULT_OFFSET = 0;
-/** The page size applied when a query omits `limit`. */
-export declare const DEFAULT_PAGE_SIZE = 20;
-//# sourceMappingURL=constants.d.ts.map

package/dist/utils/constants.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../src/utils/constants.ts"],"names":[],"mappings":"AAAA,mGAAmG;AACnG,eAAO,MAAM,aAAa,MAAM,CAAC;AAEjC,gFAAgF;AAChF,eAAO,MAAM,cAAc,IAAI,CAAC;AAEhC,wDAAwD;AACxD,eAAO,MAAM,iBAAiB,KAAK,CAAC"}

package/dist/utils/constants.js

@@ -1,6 +0,0 @@
-/** Hard cap on a page's row count - a larger `limit` is silently clamped to this, not rejected. */
-export const MAX_PAGE_SIZE = 100;
-/** The offset applied when a query omits `offset` - starts at the first row. */
-export const DEFAULT_OFFSET = 0;
-/** The page size applied when a query omits `limit`. */
-export const DEFAULT_PAGE_SIZE = 20;

package/dist/utils/include.d.ts

@@ -1,80 +0,0 @@
-import { type Table, type View } from 'drizzle-orm';
-/** An include path named a relation the schema does not hold. */
-export declare class UnknownIncludePath extends Error {
-    readonly path: string;
-    constructor(path: string);
-}
-/** One relation, narrowed to what walking a path needs. */
-interface RelationTarget {
-    referencedTableName: string;
-}
-/** A column, narrowed to what picking it needs. */
-interface ColumnTarget {
-    name: string;
-}
-/** The relational metadata drizzle computes when the client is built (`db._.schema`), narrowed the same way. */
-export interface RelationalTables {
-    [exportName: string]: {
-        dbName: string;
-        columns: Record<string, ColumnTarget>;
-        primaryKey: readonly ColumnTarget[];
-        relations: Record<string, RelationTarget>;
-    };
-}
-/** What a finder was asked to load, as its options carry it. */
-export interface RelationalReadOptions {
-    /** Fieldsets keyed by table name; a table with none loads every column. */
-    fields?: Readonly<Record<string, readonly string[] | undefined>>;
-    /** Relation paths, dot-separated as the wire states them. */
-    include?: readonly string[];
-    /** Root columns loaded on top of the root fieldset; never narrows it. */
-    columns?: Readonly<Record<string, boolean | undefined>>;
-    /** A relational config the caller spells out, winning over `include` wherever both name a relation. */
-    with?: unknown;
-}
-/** One level of drizzle's relational config: the columns it selects, and the relations it loads under it. */
-export interface RelationalRead {
-    /** Absent where every column loads. */
-    columns?: Record<string, true>;
-    /** Absent where no relation loads, which is what lets a finder take the plain `select()` path. */
-    with?: Record<string, unknown>;
-}
-/**
- * A single table or view described the way {@link RelationalTables} describes one, for a read given no schema.
- *
- * A view declares no primary key of its own; the key it reads under is whichever selected column is a primary key of
- * the table it was selected from.
- */
-export declare function describeTable(table: Table | View): RelationalTables[string];
-/**
- * `selectable` narrowed to the keys a {@link RelationalRead} level selects, for a plain `select()`.
- *
- * @param columns - a level's `columns`; absent, every one of `selectable` is kept
- */
-export declare function selectedColumns<TSelectable extends Record<string, unknown>>(selectable: TSelectable, columns: Readonly<Record<string, true>> | undefined): TSelectable;
-/**
- * What one finder call loads: resolved against the relational schema `executor` was built with where the repository
- * has a `queryKey`, and against its own table alone where it has not - so a fieldset still narrows the row.
- *
- * @param executor - the drizzle client or transaction the call runs on; its `_.schema` is drizzle's relational config
- * @throws when `include` is given and the repository has no `queryKey`, or its client no schema
- * @throws {@link UnknownIncludePath} as {@link buildRelationalRead} does
- */
-export declare function resolveRelationalRead(executor: unknown, queryKey: PropertyKey | undefined, table: Table | View, options: RelationalReadOptions | undefined): RelationalRead;
-/**
- * Resolves a read into drizzle's relational config: `fields` into each level's `columns`, `include` into nested
- * `with`, then `columns` and `with` as the caller spelled them.
- *
- * - A fieldset selects its columns and the table's primary key; a relation it names loads that relation's primary keys,
- *   which is the linkage a relationship publishes. A name that is neither loads nothing: the permit-list and the
- *   `TableQuery` type are what refuse one.
- * - An included relation replaces any linkage the fieldset gave it, and loads under its own table's fieldset.
- *
- * @param rootTable - the EXPORT name of the table the read starts from, not its table name
- * @throws {@link UnknownIncludePath} naming the path up to and including the segment that failed - drizzle@0.45.1
- *   raises on a relation it does not hold too, but as `Cannot read properties of undefined (reading
- *   'referencedTable')`, naming neither the path nor the relation
- */
-export declare function buildRelationalRead(tables: RelationalTables, rootTable: string, options: RelationalReadOptions): RelationalRead;
-export {};
-//# sourceMappingURL=include.d.ts.map

package/dist/utils/include.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"include.d.ts","sourceRoot":"","sources":["../../src/utils/include.ts"],"names":[],"mappings":"AAAA,OAAO,EAA6E,KAAK,KAAK,EAAE,KAAK,IAAI,EAAE,MAAM,aAAa,CAAC;AAE/H,iEAAiE;AACjE,qBAAa,kBAAmB,SAAQ,KAAK;IAC/B,QAAQ,CAAC,IAAI,EAAE,MAAM;gBAAZ,IAAI,EAAE,MAAM;CAGlC;AAED,2DAA2D;AAC3D,UAAU,cAAc;IACtB,mBAAmB,EAAE,MAAM,CAAC;CAC7B;AAED,mDAAmD;AACnD,UAAU,YAAY;IACpB,IAAI,EAAE,MAAM,CAAC;CACd;AAED,gHAAgH;AAChH,MAAM,WAAW,gBAAgB;IAC/B,CAAC,UAAU,EAAE,MAAM,GAAG;QACpB,MAAM,EAAE,MAAM,CAAC;QACf,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;QACtC,UAAU,EAAE,SAAS,YAAY,EAAE,CAAC;QACpC,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC;KAC3C,CAAC;CACH;AAED,gEAAgE;AAChE,MAAM,WAAW,qBAAqB;IACpC,2EAA2E;IAC3E,MAAM,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,GAAG,SAAS,CAAC,CAAC,CAAC;IACjE,6DAA6D;IAC7D,OAAO,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC5B,yEAAyE;IACzE,OAAO,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,GAAG,SAAS,CAAC,CAAC,CAAC;IACxD,uGAAuG;IACvG,IAAI,CAAC,EAAE,OAAO,CAAC;CAChB;AAED,6GAA6G;AAC7G,MAAM,WAAW,cAAc;IAC7B,uCAAuC;IACvC,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;IAC/B,kGAAkG;IAClG,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAChC;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI,GAAG,gBAAgB,CAAC,MAAM,CAAC,CAY3E;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,WAAW,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACzE,UAAU,EAAE,WAAW,EACvB,OAAO,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC,GAAG,SAAS,GAClD,WAAW,CAGb;AAED;;;;;;;GAOG;AACH,wBAAgB,qBAAqB,CACnC,QAAQ,EAAE,OAAO,EACjB,QAAQ,EAAE,WAAW,GAAG,SAAS,EACjC,KAAK,EAAE,KAAK,GAAG,IAAI,EACnB,OAAO,EAAE,qBAAqB,GAAG,SAAS,GACzC,cAAc,CAShB;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,gBAAgB,EACxB,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,qBAAqB,GAC7B,cAAc,CAmEhB"}

package/dist/utils/include.js

@@ -1,132 +0,0 @@
-import { getTableColumns, getTableName, getViewName, getViewSelectedFields, isView } from 'drizzle-orm';
-/** An include path named a relation the schema does not hold. */
-export class UnknownIncludePath extends Error {
-    path;
-    constructor(path) {
-        super(`Including "${path}" is not supported.`);
-        this.path = path;
-    }
-}
-/**
- * A single table or view described the way {@link RelationalTables} describes one, for a read given no schema.
- *
- * A view declares no primary key of its own; the key it reads under is whichever selected column is a primary key of
- * the table it was selected from.
- */
-export function describeTable(table) {
-    const view = isView(table);
-    const columns = (view ? getViewSelectedFields(table) : getTableColumns(table));
-    return {
-        dbName: view ? getViewName(table) : getTableName(table),
-        columns,
-        primaryKey: Object.values(columns).filter((column) => column.primary),
-        relations: {},
-    };
-}
-/**
- * `selectable` narrowed to the keys a {@link RelationalRead} level selects, for a plain `select()`.
- *
- * @param columns - a level's `columns`; absent, every one of `selectable` is kept
- */
-export function selectedColumns(selectable, columns) {
-    if (!columns)
-        return selectable;
-    return Object.fromEntries(Object.entries(selectable).filter(([key]) => columns[key]));
-}
-/**
- * What one finder call loads: resolved against the relational schema `executor` was built with where the repository
- * has a `queryKey`, and against its own table alone where it has not - so a fieldset still narrows the row.
- *
- * @param executor - the drizzle client or transaction the call runs on; its `_.schema` is drizzle's relational config
- * @throws when `include` is given and the repository has no `queryKey`, or its client no schema
- * @throws {@link UnknownIncludePath} as {@link buildRelationalRead} does
- */
-export function resolveRelationalRead(executor, queryKey, table, options) {
-    if (!options)
-        return {};
-    const tables = executor?._?.schema;
-    if (queryKey !== undefined && tables)
-        return buildRelationalRead(tables, String(queryKey), options);
-    if (options.include?.length) {
-        throw new Error('"include" needs a queryKey and a client built with its schema.');
-    }
-    const described = describeTable(table);
-    return buildRelationalRead({ [described.dbName]: described }, described.dbName, options);
-}
-/**
- * Resolves a read into drizzle's relational config: `fields` into each level's `columns`, `include` into nested
- * `with`, then `columns` and `with` as the caller spelled them.
- *
- * - A fieldset selects its columns and the table's primary key; a relation it names loads that relation's primary keys,
- *   which is the linkage a relationship publishes. A name that is neither loads nothing: the permit-list and the
- *   `TableQuery` type are what refuse one.
- * - An included relation replaces any linkage the fieldset gave it, and loads under its own table's fieldset.
- *
- * @param rootTable - the EXPORT name of the table the read starts from, not its table name
- * @throws {@link UnknownIncludePath} naming the path up to and including the segment that failed - drizzle@0.45.1
- *   raises on a relation it does not hold too, but as `Cannot read properties of undefined (reading
- *   'referencedTable')`, naming neither the path nor the relation
- */
-export function buildRelationalRead(tables, rootTable, options) {
-    // A relation names its target by TABLE name while `tables` is keyed by EXPORT name; looking the
-    // target up directly reads as "no such relation" wherever the two differ.
-    const byTableName = new Map(Object.entries(tables).map(([key, table]) => [table.dbName, key]));
-    const exportNameOf = (relation) => byTableName.get(relation.referencedTableName) ?? relation.referencedTableName;
-    const primaryKeyOf = (tableKey) => {
-        const table = tables[tableKey];
-        if (!table)
-            return [];
-        const names = new Set(table.primaryKey.map((column) => column.name));
-        return Object.keys(table.columns).filter((key) => names.has(table.columns[key]?.name ?? ''));
-    };
-    const selecting = (keys) => Object.fromEntries(keys.map((key) => [key, true]));
-    const levelOf = (tableKey) => {
-        const table = tables[tableKey];
-        const fieldset = table ? options.fields?.[table.dbName] : undefined;
-        if (!table || fieldset === undefined)
-            return {};
-        const level = {
-            columns: selecting([...primaryKeyOf(tableKey), ...fieldset.filter((name) => name in table.columns)]),
-        };
-        for (const name of fieldset) {
-            const relation = table.relations[name];
-            if (!relation)
-                continue;
-            level.with ??= {};
-            level.with[name] = { columns: selecting(primaryKeyOf(exportNameOf(relation))) };
-        }
-        return level;
-    };
-    const root = levelOf(rootTable);
-    const included = new Set();
-    for (const path of options.include ?? []) {
-        let tableKey = rootTable;
-        let level = root;
-        const walked = [];
-        for (const segment of path.split('.')) {
-            walked.push(segment);
-            const relation = tables[tableKey]?.relations[segment];
-            if (!relation)
-                throw new UnknownIncludePath(walked.join('.'));
-            tableKey = exportNameOf(relation);
-            level.with ??= {};
-            let next = level.with[segment];
-            if (next === undefined || !included.has(next)) {
-                next = levelOf(tableKey);
-                included.add(next);
-                level.with[segment] = next;
-            }
-            level = next;
-        }
-    }
-    if (root.columns) {
-        for (const [key, loaded] of Object.entries(options.columns ?? {})) {
-            if (loaded)
-                root.columns[key] = true;
-        }
-    }
-    if (options.with !== undefined) {
-        root.with = { ...root.with, ...options.with };
-    }
-    return root;
-}

package/dist/utils/table-query.d.ts

@@ -1,41 +0,0 @@
-import type { ExtractTablesWithRelations, FindTableByDBName, TableRelationalConfig, TablesRelationalConfig } from 'drizzle-orm';
-/** How many relations deep {@link IncludePath} spells a path; a deeper one is spelled out with `with`. */
-type IncludeDepth = 3;
-/** Indexed by a depth, the depth one relation further in. */
-type OneLess = [never, 0, 1, 2];
-/**
- * Every dotted relation path that starts at `TTable`, up to three relations deep.
- *
- * A path may come back to a table it passed through (`author.books` from a book), so depth is what keeps the type
- * finite, not the tables visited.
- */
-export type IncludePath<TSchema extends TablesRelationalConfig, TTable extends TableRelationalConfig, TDepth extends number = IncludeDepth> = [TDepth] extends [0] ? never : TTable extends TableRelationalConfig ? {
-    [K in keyof TTable['relations'] & string]: K | `${K}.${IncludePath<TSchema, FindTableByDBName<TSchema, TTable['relations'][K]['referencedTableName']>, OneLess[TDepth]>}`;
-}[keyof TTable['relations'] & string] : never;
-/**
- * A JSON:API read of one table, typed off its drizzle schema: fieldsets keyed by TABLE name holding column and relation
- * names, include paths walked by relation name.
- *
- * Its shape is the query `@zeroxsolutions/query` guards, so a guarded query whose permit-list was declared `as const`
- * and checked with `satisfies TableQuery<typeof schema, '<export name>'>` passes to a finder without a cast. A
- * repository whose schema is not given types it by name only.
- */
-export type TableQuery<TSchema extends Record<string, unknown>, TTableName extends keyof ExtractTablesWithRelations<TSchema>> = [TTableName] extends [never] ? {
-    /** As the schema-typed branch below: keyed by table name, holding column and relation names. */
-    fields?: Readonly<Record<string, readonly string[]>>;
-    /** As the schema-typed branch below: relation paths, dot-separated. */
-    include?: readonly string[];
-} : {
-    /**
-     * Fieldsets keyed by table name. A table given one loads those columns and its primary key, and each relation it
-     * names loads the related primary keys; an empty one loads the primary key alone; a table given none loads every
-     * column.
-     */
-    fields?: {
-        [K in keyof ExtractTablesWithRelations<TSchema> as ExtractTablesWithRelations<TSchema>[K]['dbName']]?: readonly ((keyof ExtractTablesWithRelations<TSchema>[K]['columns'] | keyof ExtractTablesWithRelations<TSchema>[K]['relations']) & string)[];
-    };
-    /** Relation paths, dot-separated; each relation loads under its own table's fieldset. Needs a `queryKey`. */
-    include?: readonly IncludePath<ExtractTablesWithRelations<TSchema>, ExtractTablesWithRelations<TSchema>[TTableName]>[];
-};
-export {};
-//# sourceMappingURL=table-query.d.ts.map

package/dist/utils/table-query.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"table-query.d.ts","sourceRoot":"","sources":["../../src/utils/table-query.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,0BAA0B,EAC1B,iBAAiB,EACjB,qBAAqB,EACrB,sBAAsB,EACvB,MAAM,aAAa,CAAC;AAErB,0GAA0G;AAC1G,KAAK,YAAY,GAAG,CAAC,CAAC;AAEtB,6DAA6D;AAC7D,KAAK,OAAO,GAAG,CAAC,KAAK,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;AAEhC;;;;;GAKG;AACH,MAAM,MAAM,WAAW,CACrB,OAAO,SAAS,sBAAsB,EACtC,MAAM,SAAS,qBAAqB,EACpC,MAAM,SAAS,MAAM,GAAG,YAAY,IAClC,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC,CAAC,GACpB,KAAK,GACL,MAAM,SAAS,qBAAqB,GAClC;KACG,CAAC,IAAI,MAAM,MAAM,CAAC,WAAW,CAAC,GAAG,MAAM,GACpC,CAAC,GACD,GAAG,CAAC,IAAI,WAAW,CAAC,OAAO,EAAE,iBAAiB,CAAC,OAAO,EAAE,MAAM,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC,qBAAqB,CAAC,CAAC,EAAE,OAAO,CAAC,MAAM,CAAC,CAAC,EAAE;CAC/H,CAAC,MAAM,MAAM,CAAC,WAAW,CAAC,GAAG,MAAM,CAAC,GACrC,KAAK,CAAC;AAEZ;;;;;;;GAOG;AACH,MAAM,MAAM,UAAU,CACpB,OAAO,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACvC,UAAU,SAAS,MAAM,0BAA0B,CAAC,OAAO,CAAC,IAC1D,CAAC,UAAU,CAAC,SAAS,CAAC,KAAK,CAAC,GAC5B;IACE,gGAAgG;IAChG,MAAM,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC,CAAC,CAAC;IACrD,uEAAuE;IACvE,OAAO,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CAC7B,GACD;IACE;;;;OAIG;IACH,MAAM,CAAC,EAAE;SACN,CAAC,IAAI,MAAM,0BAA0B,CAAC,OAAO,CAAC,IAAI,0BAA0B,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE,SAAS,CAAC,CAC7G,MAAM,0BAA0B,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,GACvD,MAAM,0BAA0B,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,WAAW,CAAC,CAC5D,GACC,MAAM,CAAC,EAAE;KACZ,CAAC;IACF,6GAA6G;IAC7G,OAAO,CAAC,EAAE,SAAS,WAAW,CAAC,0BAA0B,CAAC,OAAO,CAAC,EAAE,0BAA0B,CAAC,OAAO,CAAC,CAAC,UAAU,CAAC,CAAC,EAAE,CAAC;CACxH,CAAC"}

package/dist/utils/table-query.js

@@ -1 +0,0 @@
-export {};

package/dist/utils/total-order.d.ts

@@ -1,15 +0,0 @@
-import type { SortField } from '@zeroxsolutions/query';
-import { PgTable, type TableConfig as PgTableConfig } from 'drizzle-orm/pg-core';
-import { type SQLiteTable, type TableConfig as SQLiteTableConfig } from 'drizzle-orm/sqlite-core';
-type OrderableTable = PgTable<PgTableConfig> | SQLiteTable<SQLiteTableConfig>;
-/**
- * The caller's sort followed by each primary key column it does not already name, ascending, so no
- * two rows tie and every page of a walk is cut from the same order.
- *
- * Kept apart from `buildOrderBy`, which a consumer applies one clause at a time to build its own
- * order: a key appended to each clause would land in the middle of that order. Kept out of
- * `utils/index.ts` too, which re-exports everything it names.
- */
-export declare function totalOrder(table: OrderableTable, sort: SortField[] | undefined): SortField[];
-export {};
-//# sourceMappingURL=total-order.d.ts.map

package/dist/utils/total-order.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"total-order.d.ts","sourceRoot":"","sources":["../../src/utils/total-order.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAEvD,OAAO,EAAsC,OAAO,EAAE,KAAK,WAAW,IAAI,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACrH,OAAO,EAEL,KAAK,WAAW,EAChB,KAAK,WAAW,IAAI,iBAAiB,EACtC,MAAM,yBAAyB,CAAC;AAEjC,KAAK,cAAc,GAAG,OAAO,CAAC,aAAa,CAAC,GAAG,WAAW,CAAC,iBAAiB,CAAC,CAAC;AAE9E;;;;;;;GAOG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,cAAc,EAAE,IAAI,EAAE,SAAS,EAAE,GAAG,SAAS,GAAG,SAAS,EAAE,CAO5F"}

package/dist/utils/total-order.js

@@ -1,35 +0,0 @@
-import { getTableColumns, is } from 'drizzle-orm';
-import { getTableConfig as getPgTableConfig, PgTable } from 'drizzle-orm/pg-core';
-import { getTableConfig as getSQLiteTableConfig, } from 'drizzle-orm/sqlite-core';
-/**
- * The caller's sort followed by each primary key column it does not already name, ascending, so no
- * two rows tie and every page of a walk is cut from the same order.
- *
- * Kept apart from `buildOrderBy`, which a consumer applies one clause at a time to build its own
- * order: a key appended to each clause would land in the middle of that order. Kept out of
- * `utils/index.ts` too, which re-exports everything it names.
- */
-export function totalOrder(table, sort) {
-    const requested = sort ?? [];
-    const named = new Set(requested.map((item) => item.field));
-    const appended = primaryKeyFields(table)
-        .filter((field) => !named.has(field))
-        .map((field) => ({ field, direction: 'asc' }));
-    return [...requested, ...appended];
-}
-/**
- * The property keys of the table's primary key columns, in the order the key declares them.
- *
- * A property key and not the SQL name, because a `SortField` names a column the way
- * `getTableColumns` keys it. A composite key sets no column's `primary` flag, so it is read off the
- * table config instead, and matched back by SQL name: pg-core hands the key its own copies of the
- * columns, so the key's column objects are not the table's (drizzle-orm@0.45.1).
- */
-function primaryKeyFields(table) {
-    const columns = getTableColumns(table);
-    const fieldOf = new Map(Object.entries(columns).map(([field, column]) => [column.name, field]));
-    const declared = Object.values(columns).filter((column) => column.primary);
-    const composite = (is(table, PgTable) ? getPgTableConfig(table) : getSQLiteTableConfig(table)).primaryKeys[0]?.columns;
-    const keyColumns = declared.length > 0 ? declared : (composite ?? []);
-    return keyColumns.flatMap((column) => fieldOf.get(column.name) ?? []);
-}