okmodel 0.1.1 → 0.3.0

package/dist/dialects/pg/column.d.ts

@@ -2,9 +2,10 @@
  * Column builder shared by every Postgres type.
  *
  * Modifiers allocate a new builder when called. Importing this module does
- * not build a codec table. `.validate()` stays a slot for P26.
+ * not build a codec table. `.validate()` stores rules and does not run them.
  */
-import { type ReferentialAction } from "../../contracts/catalog/types.js";
+import { type CatalogObject, type Namespace, type Provenance, type ReferentialAction } from "../../contracts/catalog/types.js";
+import { type ClientFill } from "../../contracts/generator.js";
 /** Flags that decide the row, insert, and update shapes of one column. */
 export type ColumnFlags = {
     readonly nullable: boolean;
@@ -13,6 +14,8 @@ export type ColumnFlags = {
     readonly guarded: boolean;
     readonly hidden: boolean;
     readonly omitWrite: boolean;
+    /** Absent from update. Insert still follows {@link InsertKind}. */
+    readonly omitUpdate: boolean;
 };
 /** Flags for a required column with no default. */
 export type PlainFlags = {
@@ -22,8 +25,9 @@ export type PlainFlags = {
     readonly guarded: false;
     readonly hidden: false;
     readonly omitWrite: false;
+    readonly omitUpdate: false;
 };
-/** Flags for {@link id}. Insert and update omit it. */
+/** Flags for {@link id} when the database fills the value. Insert and update omit it. */
 export type IdFlags = {
     readonly nullable: false;
     readonly hasDefault: true;
@@ -31,6 +35,21 @@ export type IdFlags = {
     readonly guarded: true;
     readonly hidden: false;
     readonly omitWrite: true;
+    readonly omitUpdate: true;
+};
+/**
+ * Flags for {@link id} with `default: "none"`.
+ *
+ * Insert requires the value. Update omits it.
+ */
+export type IdSuppliedFlags = {
+    readonly nullable: false;
+    readonly hasDefault: false;
+    readonly generated: false;
+    readonly guarded: false;
+    readonly hidden: false;
+    readonly omitWrite: false;
+    readonly omitUpdate: true;
 };
 /** Flags for {@link identity}. The database fills the value. */
 export type IdentityFlags = {
@@ -40,6 +59,7 @@ export type IdentityFlags = {
     readonly guarded: false;
     readonly hidden: false;
     readonly omitWrite: true;
+    readonly omitUpdate: true;
 };
 /**
  * Turns one flag on.
@@ -58,6 +78,14 @@ export type FlagTrue<TFlags extends ColumnFlags, K extends keyof ColumnFlags> =
 export type WithGenerated<TFlags extends ColumnFlags> = {
     readonly [P in keyof TFlags]: P extends "generated" | "hasDefault" ? true : TFlags[P];
 };
+/**
+ * Omits a column from update and leaves insert unchanged.
+ *
+ * @typeParam TFlags - Current flags
+ */
+export type WithUpdateGuard<TFlags extends ColumnFlags> = {
+    readonly [P in keyof TFlags]: P extends "omitUpdate" ? true : TFlags[P];
+};
 /** How a default expression is spelled in the catalog. */
 export type SqlForm = "raw" | "quote" | "json" | "jsonb" | "cast";
 /**
@@ -70,7 +98,14 @@ export type ReferenceModifier = {
     readonly table: string;
     readonly onDelete?: ReferentialAction;
     readonly onUpdate?: ReferentialAction;
+    /** Target columns. Several columns make a composite foreign key. */
     readonly columns?: readonly string[];
+    /**
+     * Other local columns in the foreign key, after this column.
+     *
+     * Set when the key is composite. Absent on a single-column reference.
+     */
+    readonly along?: readonly string[];
 };
 /**
  * Options for {@link ColumnBuilder.references}.
@@ -81,7 +116,7 @@ export type ReferenceOptions = {
     readonly columns?: readonly string[];
 };
 /**
- * Validation rules, stored when a later prompt adds `.validate()`.
+ * Validation rules stored on the column. Nothing here interprets them.
  */
 export type ValidateModifier = {
     readonly rules: readonly unknown[];
@@ -114,7 +149,7 @@ export type ColumnInsert<TFlags extends ColumnFlags, TValue> = InsertKind<TFlags
  * @typeParam TFlags - Column flags
  * @typeParam TValue - Scalar or array value
  */
-export type ColumnUpdate<TFlags extends ColumnFlags, TValue> = InsertKind<TFlags> extends "omit" ? never : TFlags["nullable"] extends true ? TValue | null | undefined : TValue | undefined;
+export type ColumnUpdate<TFlags extends ColumnFlags, TValue> = TFlags["omitUpdate"] extends true ? never : InsertKind<TFlags> extends "omit" ? never : TFlags["nullable"] extends true ? TValue | null | undefined : TValue | undefined;
 /**
  * Row shape of a builder.
  *
@@ -141,6 +176,20 @@ export type ColumnState<TValue> = {
     readonly hasDefault: boolean;
     readonly defaultSql: string | undefined;
     readonly defaultValue: unknown;
+    /**
+     * Client generator. Absent from the catalog and its hash.
+     *
+     * The catalog output labels it `client`. Insert fills the column when the
+     * caller omits it.
+     */
+    readonly clientDefault: ClientFill | undefined;
+    /** Column collation. Omitted from the catalog when unset. */
+    readonly collation: string | undefined;
+    /**
+     * `implicit` is a bare `t.id()`. `schema({ defaults: { id } })` may replace
+     * it. `column` is a choice on that column and wins.
+     */
+    readonly idSource: "implicit" | "column" | undefined;
     readonly identity: {
         readonly always: boolean;
     } | undefined;
@@ -158,7 +207,10 @@ export type ColumnState<TValue> = {
     } | undefined;
     readonly guarded: boolean;
     readonly hidden: boolean;
+    /** Redacted in logs, errors, and `inspect()`. Not part of the catalog hash. */
+    readonly sensitive: boolean;
     readonly omitWrite: boolean;
+    readonly omitUpdate: boolean;
     readonly renamedFrom: string | undefined;
     readonly sqlName: string | undefined;
     readonly comment: string | undefined;
@@ -169,6 +221,7 @@ export type ColumnState<TValue> = {
     readonly domain: {
         readonly base: string;
         readonly check: string;
+        readonly emit?: (namespace: Namespace, provenance: Provenance, objects: CatalogObject[]) => void;
     } | undefined;
     readonly primaryKey: boolean;
     readonly typeLabel: string | undefined;
@@ -179,6 +232,11 @@ export type ColumnState<TValue> = {
     readonly decode: (wire: string) => TValue;
     readonly elementEncode: (value: unknown) => string;
     readonly elementDecode: (wire: string) => unknown;
+    /**
+     * Object kinds the codec takes as input, named by `Object.prototype.toString`
+     * (`"Array"`, `"Temporal.Instant"`). Absent when the codec takes only scalars.
+     */
+    readonly accepts: readonly string[] | undefined;
 };
 /** Fields a scalar builder sets. Flags are passed beside the codec. */
 export type OpenColumn<TValue> = {
@@ -189,10 +247,15 @@ export type OpenColumn<TValue> = {
     readonly guarded: boolean;
     readonly hidden: boolean;
     readonly omitWrite: boolean;
+    readonly omitUpdate?: boolean;
     readonly encode: (value: TValue) => string;
     readonly decode: (wire: string) => TValue;
+    readonly accepts?: readonly string[];
     readonly sqlForm: SqlForm;
     readonly defaultSql?: string;
+    readonly clientDefault?: ClientFill;
+    readonly collation?: string;
+    readonly idSource?: "implicit" | "column";
     readonly identity?: {
         readonly always: boolean;
     };
@@ -202,6 +265,7 @@ export type OpenColumn<TValue> = {
     readonly domain?: {
         readonly base: string;
         readonly check: string;
+        readonly emit?: (namespace: Namespace, provenance: Provenance, objects: CatalogObject[]) => void;
     };
     readonly primaryKey?: boolean;
     readonly typeLabel?: string;
@@ -248,12 +312,16 @@ export declare class ColumnBuilder<TValue, TFlags extends ColumnFlags> {
      */
     nullable(): ColumnBuilder<TValue, FlagTrue<TFlags, "nullable">>;
     /**
-     * Stores a JavaScript default. The catalog receives its SQL spelling.
+     * Stores a literal database default, or a client generator.
+     *
+     * A literal is written into the catalog as SQL. A function is a client
+     * generator: insert fills the column when it is omitted, and the catalog
+     * stores no default. Pass `uuidv4`, `uuidv7`, `okid(...)`, or any function.
      *
-     * @param value - Default value
+     * @param value - Literal default, or a function that returns one value
      * @returns The same column, with a default
      */
-    default(value: TFlags["nullable"] extends true ? TValue | null : TValue): ColumnBuilder<TValue, FlagTrue<TFlags, "hasDefault">>;
+    default(value: (TFlags["nullable"] extends true ? TValue | null : TValue) | (() => TValue)): ColumnBuilder<TValue, FlagTrue<TFlags, "hasDefault">>;
     /**
      * Stores a SQL default expression as written.
      *
@@ -262,14 +330,26 @@ export declare class ColumnBuilder<TValue, TFlags extends ColumnFlags> {
      */
     defaultSql(expression: string): ColumnBuilder<TValue, FlagTrue<TFlags, "hasDefault">>;
     /**
-     * Records a unique constraint. Tenancy later reads `global`.
+     * Makes this column the table's primary key.
+     *
+     * Insert still accepts the value. Update omits it. A composite key is the
+     * `primaryKey` option on `table()`, not a second call.
+     *
+     * @returns The same column, as a primary key
+     */
+    primaryKey(): ColumnBuilder<TValue, WithUpdateGuard<TFlags>>;
+    /**
+     * Records a unique constraint.
+     *
+     * On a tenant table the key is included, unless `global` names a reason.
+     * `global: "reason"` and `{ global: true, reason }` are the same opt-out.
      *
      * @param options - Exemption reason, and whether the unique ignores the tenant key
      * @returns The same column
      */
     unique(options?: {
         readonly reason?: string;
-        readonly global?: boolean;
+        readonly global?: boolean | string;
     }): ColumnBuilder<TValue, TFlags>;
     /**
      * Narrows a string column to a literal union.
@@ -303,9 +383,33 @@ export declare class ColumnBuilder<TValue, TFlags extends ColumnFlags> {
     /**
      * Excludes the column from the default row.
      *
+     * A named `select` still returns it. Includes never do.
+     *
      * @returns The same column, hidden
      */
     hidden(): ColumnBuilder<TValue, FlagTrue<TFlags, "hidden">>;
+    /**
+     * Redacts the value in logs, errors, and `inspect()`.
+     *
+     * The stored value is unchanged. A read that selects the column still
+     * returns it. The catalog hash does not include this flag.
+     *
+     * @returns The same column, sensitive
+     */
+    sensitive(): ColumnBuilder<TValue, TFlags>;
+    /**
+     * Stores validation rules or one Standard Schema.
+     *
+     * The rules are stored. They run only when validation is enabled and the
+     * engine has loaded. A field listed here and in the table `validate`
+     * section is OKM1030, reported by `okm check`.
+     *
+     * @param rules - Rule list, or one Standard Schema
+     * @returns The same column, with the rules stored
+     */
+    validate(rules: readonly unknown[] | {
+        readonly "~standard": unknown;
+    }): ColumnBuilder<TValue, TFlags>;
     /**
      * Points this column at another table.
      *
@@ -384,3 +488,18 @@ export declare function formatType(baseType: string, dims: number): string;
  * @returns A default expression
  */
 export declare function sqlOf<TValue>(state: ColumnState<TValue>, value: TValue): string;
+/**
+ * Returns a column with a cleared unique flag or a replaced reference.
+ *
+ * `okmodel/tenancy` uses this while rewriting tables. `schema()` then compiles
+ * the result with the ordinary unique and foreign-key paths.
+ *
+ * @param column - Column to copy
+ * @param patch - Unique or primary flag to drop, or the reference to store
+ * @returns A new column builder
+ */
+export declare function retarget<TValue, TFlags extends ColumnFlags>(column: ColumnBuilder<TValue, TFlags>, patch: {
+    readonly dropUnique?: boolean;
+    readonly dropPrimary?: boolean;
+    readonly references?: ReferenceModifier;
+}): ColumnBuilder<TValue, TFlags>;

package/dist/dialects/pg/compile.d.ts

@@ -12,6 +12,7 @@ export type CompilableColumn = {
         readonly dims: number;
         readonly nullable: boolean;
         readonly defaultSql: string | undefined;
+        readonly collation: string | undefined;
         readonly identity: {
             readonly always: boolean;
         } | undefined;

package/dist/dialects/pg/custom.d.ts

@@ -16,6 +16,12 @@ export declare function custom<TValue>(spec: {
     readonly sqlType: string;
     readonly encode: (value: TValue) => string;
     readonly decode: (wire: string) => TValue;
+    /**
+     * Object kinds the codec takes, as `Object.prototype.toString` names them: `"Object"`
+     * for a plain object, `"Array"`, `"Temporal.Instant"`. Omit it when `TValue` is a
+     * scalar: every object is then rejected (OKM1121).
+     */
+    readonly accepts?: readonly string[];
     readonly extension?: string;
     readonly sqlForm?: SqlForm;
 }): ColumnBuilder<TValue, PlainFlags>;

package/dist/dialects/pg/ddl.d.ts

@@ -4,7 +4,7 @@
  * Planning and scratch comparison both render through here, so a statement
  * has one spelling.
  */
-import type { Catalog, CatalogObject, ColumnObject, SequenceObject, TableObject } from "../../contracts/catalog/types.js";
+import type { Catalog, CatalogObject, ColumnObject, FunctionObject, MaterializedViewObject, SequenceObject, TableObject, ViewObject } from "../../contracts/catalog/types.js";
 /**
  * Quotes one identifier.
  *
@@ -23,6 +23,15 @@ export declare function quoteIdent(name: string): string;
  * @returns SQL statements
  */
 export declare function renderCatalog(source: Catalog, schema: string): readonly string[];
+/**
+ * Reports whether an index belongs to a view or a materialized view.
+ *
+ * Those indexes are created after the view, not with the tables.
+ *
+ * @param object - Catalog object
+ * @returns `true` when an index edge points at a view
+ */
+export declare function ownedByView(object: CatalogObject): boolean;
 /**
  * SQL that drops one object.
  *
@@ -42,6 +51,53 @@ export declare function dropObjectSql(object: CatalogObject, schema: string): st
  * @returns The statement
  */
 export declare function createObjectSql(object: CatalogObject, schema: string): string | undefined;
+/**
+ * `CREATE` or `CREATE OR REPLACE` for one function.
+ *
+ * A compatible signature change uses replace. The body is the stored source,
+ * or the `BEGIN ATOMIC` block when the function is atomic.
+ *
+ * @param object - Function to render
+ * @param schema - Concrete schema name
+ * @param replace - `CREATE OR REPLACE` when true
+ * @returns The statement
+ */
+export declare function functionSql(object: FunctionObject, schema: string, replace: boolean): string;
+/**
+ * `CREATE` or `CREATE OR REPLACE` for one view.
+ *
+ * Appending columns is replace. The query is the stored text.
+ *
+ * @param object - View to render
+ * @param schema - Concrete schema name
+ * @param replace - `CREATE OR REPLACE` when true
+ * @returns The statement
+ */
+export declare function viewSql(object: ViewObject, schema: string, replace: boolean): string;
+/**
+ * `CREATE MATERIALIZED VIEW ... WITH NO DATA`.
+ *
+ * Populate is a separate planned step. This statement does not read the table.
+ *
+ * @param object - Materialized view to render
+ * @param schema - Concrete schema name
+ * @returns The statement
+ */
+export declare function materializedViewSql(object: MaterializedViewObject, schema: string): string;
+/**
+ * `REFRESH MATERIALIZED VIEW`.
+ *
+ * A view created `WITH NO DATA` is empty, and Postgres rejects `CONCURRENTLY`
+ * until it has been populated once. The plan's populate step passes
+ * `populated: false`. A later refresh uses `CONCURRENTLY` when the declaration
+ * asked for it.
+ *
+ * @param object - Materialized view to refresh
+ * @param schema - Concrete schema name
+ * @param populated - `true` when the view already holds rows
+ * @returns The statement
+ */
+export declare function refreshMaterializedViewSql(object: MaterializedViewObject, schema: string, populated?: boolean): string;
 /**
  * In-place column changes: type, nullability, and default.
  *
@@ -68,3 +124,11 @@ export declare function identitySequence(sequence: SequenceObject, source: Catal
  * @returns The statement
  */
 export declare function createTableSql(tableObject: TableObject, source: Catalog, schema: string): string;
+/**
+ * Quotes a schema-qualified name.
+ *
+ * @param schema - Concrete schema name
+ * @param name - Object name
+ * @returns `"schema"."name"`
+ */
+export declare function qualify(schema: string, name: string): string;

package/dist/dialects/pg/enum.d.ts

@@ -2,7 +2,7 @@
  * Enum and domain columns.
  *
  * The catalog column type is the type name. Compile records a dependency on
- * the enum, and `schema()` stores that enum as a catalog type.
+ * the type, and the column's `emit` adds that type when the catalog is built.
  */
 import { type ColumnBuilder, type ColumnFlags, type PlainFlags } from "./column.js";
 /**
@@ -17,14 +17,16 @@ import { type ColumnBuilder, type ColumnFlags, type PlainFlags } from "./column.
  */
 export declare function enumColumn<const TValues extends readonly string[]>(name: string, values: TValues): ColumnBuilder<TValues[number], PlainFlags>;
 /**
- * A named domain over a scalar column.
+ * A named domain over a column type.
  *
- * Domains are not catalog objects in this version. Calling the builder fails
- * with OKM1061 until 0.3, when a domain becomes a `type` subkind (D141).
+ * The TypeScript row type and the codec are the base column's. The catalog
+ * column type is the domain name, and the domain is a `type` object (D141).
+ * An enum base is OKM1060. Changing the base type of an existing domain is
+ * OKM1020 when the plan is built.
  *
  * @param name - Domain name
- * @param base - Scalar column the domain is based on
- * @param check - Domain check expression
- * @returns A domain column with the base codec, once 0.3 supports it
+ * @param base - Column the domain is based on
+ * @param check - Domain check expression, stored as written
+ * @returns A domain column
  */
-export declare function domain<TValue, TFlags extends ColumnFlags>(_name: string, _base: ColumnBuilder<TValue, TFlags>, _check: string): ColumnBuilder<TValue, PlainFlags>;
+export declare function domain<TValue, TFlags extends ColumnFlags>(name: string, base: ColumnBuilder<TValue, TFlags>, check: string): ColumnBuilder<TValue, TFlags>;

package/dist/dialects/pg/ext/citext.d.ts

@@ -0,0 +1,14 @@
+/**
+ * The `citext` extension.
+ *
+ * Case-insensitive equality is the column's ordinary `eq` once the type is
+ * `citext`. This module declares the extension so that column can build.
+ */
+import { type Extension, type ExtensionOptions } from "./index.js";
+/**
+ * Declares `citext`.
+ *
+ * @param options - Schema and version pin. The version differs by Postgres major, so the default is unpinned.
+ * @returns The extension object
+ */
+export declare function citext(options?: ExtensionOptions): Extension;

package/dist/dialects/pg/ext/citext.js

@@ -0,0 +1,11 @@
+import {
+  extension2
+} from "../../../shared/7fvtrkwr.js";
+
+// src/dialects/pg/ext/citext.ts
+function citext(options = {}) {
+  return extension2("citext", options);
+}
+export {
+  citext
+};

package/dist/dialects/pg/ext/index.d.ts

@@ -0,0 +1,52 @@
+/**
+ * `okmodel/ext`.
+ *
+ * `extension()` returns an object that produces its own catalog record.
+ * Duplicate and undeclared-use checks run here. Core only asks each declared
+ * object for its records.
+ */
+import type { ExtensionObject } from "../../../contracts/catalog/types.js";
+/** Options on {@link extension}. */
+export type ExtensionOptions = {
+    /** Exact pin (`1.6`) or a floor (`>=0.7`). Omitted means unpinned. */
+    readonly version?: string;
+    /** Install schema. The default is `public`. */
+    readonly schema?: string;
+    /**
+     * Whether the extension may move.
+     *
+     * The default is `true`. A move of a non-relocatable extension is OKM1814.
+     */
+    readonly relocatable?: boolean;
+};
+/**
+ * One declared extension.
+ *
+ * Methods on a built-in, such as `pgTrgm.similar`, are the typed API. They
+ * are not stored in the catalog record.
+ */
+export type Extension = {
+    readonly name: string;
+    readonly schema: string;
+    readonly relocatable: boolean;
+    readonly version?: string;
+    /**
+     * Catalog records for this declaration.
+     *
+     * @param peers - The `schema({ extensions })` list
+     * @param built - Objects the schema has already staged
+     * @returns The extension record
+     */
+    contribute(peers: unknown, built: unknown): readonly ExtensionObject[];
+};
+/**
+ * Declares an extension by name.
+ *
+ * A bare declaration has the full lifecycle and no typed operators. Built-ins
+ * wrap this and add their own methods.
+ *
+ * @param name - Extension name, such as `citext` or `vector`
+ * @param options - Schema, version pin, and whether it may move
+ * @returns The definition object `schema({ extensions })` stores
+ */
+export declare function extension(name: string, options?: ExtensionOptions): Extension;

package/dist/dialects/pg/ext/index.js

@@ -0,0 +1,6 @@
+import {
+  extension2
+} from "../../../shared/7fvtrkwr.js";
+export {
+  extension2 as extension
+};

package/dist/dialects/pg/ext/pg-trgm.d.ts

@@ -0,0 +1,53 @@
+/**
+ * The `pg_trgm` extension.
+ *
+ * `similar` and `wordSimilar` are where-operators. Their SQL lives in the
+ * lazy operator module. Index methods set the catalog `expression` to a
+ * `using …` tail; the core index factory does not grow a `using` field.
+ */
+import { type Tagged } from "../operators.js";
+import type { IndexCall } from "../table.js";
+import { type Extension, type ExtensionOptions } from "./index.js";
+/** Operand stored on a trigram operator. */
+export type TrigramQuery = {
+    readonly query: string;
+    readonly schema: string;
+};
+/** `pg_trgm` plus its operators and index methods. */
+export type PgTrgm = Extension & {
+    /**
+     * `column % query`.
+     *
+     * @param query - The text to compare
+     * @returns A tagged where-operator
+     */
+    similar(query: string): Tagged<"similar", TrigramQuery>;
+    /**
+     * `column <% query`.
+     *
+     * @param query - The text to compare
+     * @returns A tagged where-operator
+     */
+    wordSimilar(query: string): Tagged<"wordSimilar", TrigramQuery>;
+    /**
+     * A GIN index with `gin_trgm_ops`.
+     *
+     * @param column - SQL column name
+     * @returns An index call whose expression is the `using` tail
+     */
+    gin(column: string): IndexCall;
+    /**
+     * A GiST index with `gist_trgm_ops`.
+     *
+     * @param column - SQL column name
+     * @returns An index call whose expression is the `using` tail
+     */
+    gist(column: string): IndexCall;
+};
+/**
+ * Declares `pg_trgm`.
+ *
+ * @param options - Schema and version pin
+ * @returns The extension object and its operators
+ */
+export declare function pgTrgm(options?: ExtensionOptions): PgTrgm;

package/dist/dialects/pg/ext/pg-trgm.js

@@ -0,0 +1,42 @@
+import {
+  extension2
+} from "../../../shared/7fvtrkwr.js";
+import {
+  tag
+} from "../../../shared/cn0n68ft.js";
+
+// src/dialects/pg/ext/pg-trgm.ts
+function pgTrgm(options = {}) {
+  const declared = extension2("pg_trgm", options);
+  const schema = declared.schema;
+  return {
+    ...declared,
+    similar(query) {
+      return tag("similar", { query, schema });
+    },
+    wordSimilar(query) {
+      return tag("wordSimilar", { query, schema });
+    },
+    gin(column) {
+      return usingIndex(column, "gin", "gin_trgm_ops");
+    },
+    gist(column) {
+      return usingIndex(column, "gist", "gist_trgm_ops");
+    }
+  };
+}
+function usingIndex(column, method, opclass) {
+  const quoted = `"${column.replaceAll('"', '""')}"`;
+  const call = {
+    columns: [column],
+    isUnique: false,
+    expression: `using ${method} (${quoted} ${opclass})`,
+    unique() {
+      return call;
+    }
+  };
+  return call;
+}
+export {
+  pgTrgm
+};

package/dist/dialects/pg/filter-parse.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Turns an allowlisted request object into `where` and `orderBy`.
+ *
+ * Loaded the first time `parse()` is called. `filters()` validates the spec
+ * before this module exists.
+ */
+import type { ParsedFilters } from "./table.js";
+/**
+ * Reads one request object.
+ *
+ * A plain value is equality when `eq` is allowlisted. `sort` is a field name
+ * from the sort list. JSON cannot add an operator.
+ *
+ * @param allow - Fields and the operators each one accepts
+ * @param sort - Fields a caller may sort by
+ * @param query - One request object
+ * @returns Filters a caller can spread into `find`
+ */
+export declare function parseQuery(allow: Readonly<Record<string, readonly string[]>>, sort: readonly string[], query: unknown): ParsedFilters;

package/dist/dialects/pg/filters.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Allowlisted filters. The checks run when `filters()` is called.
+ *
+ * A hidden field in `allow`, `sort`, or `relations` is OKM1123. The parser
+ * loads on the first `parse()`.
+ */
+import type { FilterSpec, ParsedFilters } from "./table.js";
+/**
+ * Checks an allowlist and returns `parse`.
+ *
+ * @param table - Table the filters belong to
+ * @param relations - Relation calls stored on the table, when it has any
+ * @param spec - Allow, sort, and relation fields
+ * @param hiddenFields - `table.field` keys recorded while tables were defined
+ * @returns A parser for one request object
+ */
+export declare function openFilters(table: string, relations: unknown, spec: FilterSpec, hiddenFields: ReadonlySet<string>): {
+    parse(query: unknown): Promise<ParsedFilters>;
+};