@thomasfosterau/effect-drizzle-ext 0.0.0 → 0.1.0

package/dist/index-CFhgcF4N.d.ts

@@ -0,0 +1,418 @@
+import * as Option from "effect/Option";
+import * as Schema from "effect/Schema";
+declare const DerivationError_base: Schema.Class<DerivationError, Schema.TaggedStruct<"DerivationError", {
+  readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * A construction-time derivation failure: a table or a tree could not be built
+ * from its declarations (no builder registered for a column kind, a
+ * `references` annotation with no resolver, numeric bounds on a column the
+ * table has no column for, an unresolvable FK target, a tree level whose
+ * parent is missing or forms a cycle).
+ *
+ * **Thrown, never failed.** Derivation runs at module load, before an Effect
+ * runtime exists, so the only way to stop a misdeclared table or tree from
+ * reaching production is to make its `import` fail. It is a tagged error all
+ * the same, so a consumer that does catch one (a registry loader, a codegen
+ * script) can match it structurally.
+ */
+declare class DerivationError extends DerivationError_base {}
+/**
+ * How a level stores its columns. `"plain"` (the default): one version table
+ * carrying every level column. `"fact-scoped"`: an `(id, version)` spine plus
+ * one fact table per level column, where a fact's absence at a version is its
+ * `NULL` (website's 6NF `manifestation_version` pilot).
+ */
+type LevelKind = "plain" | "fact-scoped";
+/**
+ * One level's declaration, generic in the names its `parent` may take and in
+ * the leaf payload. Optional members are `?: T | undefined` so a caller can
+ * forward its own optional.
+ */
+interface LevelSpec<Parent extends string = string, Leaf = unknown> {
+  /** The parent level. Absent: a child of the root (a branch root). */
+  readonly parent?: Parent | undefined;
+  /** How the level stores its columns; `"plain"` when absent. */
+  readonly kind?: LevelKind | undefined;
+  /**
+   * Level columns: `dbColumn`-annotated fields on this level's version table,
+   * contributed to every descendant's view. Every field must carry a
+   * `dbColumn` annotation.
+   */
+  readonly columns?: Schema.Struct.Fields | undefined;
+  /** The leaf payload. Present: a concrete leaf; absent: a marker level. */
+  readonly leaf?: Leaf | undefined;
+}
+/**
+ * The constraint a tree declaration `S` is checked against: every entry is a
+ * {@link LevelSpec} whose `parent` names **another** level of `S`, plus the
+ * consumer's extension record `Ext` (pulpit's `owned` / `pageable` flags, say),
+ * whose names the library never learns. A parent naming no level, or the level
+ * itself, is a type error at the declaration.
+ */
+type CheckedTreeSpec<S, Leaf, Ext> = { readonly [K in keyof S]: LevelSpec<Exclude<keyof S & string, K>, Leaf> & Ext; };
+/** Every level name a tree declaration `S` declares (a `Tree` reads its own). */
+type LevelName<S> = keyof S & string;
+/** The names of the leaf levels of declaration `S`: the discriminator values. */
+type LeafName<S> = { readonly [K in keyof S]: S[K] extends {
+  readonly leaf?: infer L;
+} ? [Exclude<L, undefined>] extends [never] ? never : K : never; }[keyof S] & string;
+/** The names of the marker (non-leaf) levels of declaration `S`. */
+type MarkerName<S> = Exclude<LevelName<S>, LeafName<S>>;
+/** Everything derived about one level of a tree. */
+interface TreeLevel<S> {
+  /** The level's name (a leaf's discriminator value). */
+  readonly name: LevelName<S>;
+  /** The declaration entry, extension flags included. */
+  readonly entry: S[LevelName<S>];
+  /** The parent level; `Option.none()` for a branch root. */
+  readonly parent: Option.Option<LevelName<S>>;
+  /** The level kind, `"plain"` when the entry names none. */
+  readonly kind: LevelKind;
+  /** Whether the level is a concrete leaf. */
+  readonly isLeaf: boolean;
+  /** Every ancestor, root-most first, the level itself excluded. */
+  readonly ancestors: ReadonlyArray<LevelName<S>>;
+  /** The direct children, in declaration order. */
+  readonly children: ReadonlyArray<LevelName<S>>;
+  /** Every descendant, in declaration order, the level itself excluded. */
+  readonly descendants: ReadonlyArray<LevelName<S>>;
+  /**
+   * The leaves of the level's subtree in declaration order, the level itself
+   * included when it is a leaf: the value set of its discriminator CHECK.
+   */
+  readonly subtreeLeaves: ReadonlyArray<LeafName<S>>;
+  /** The branch root the level belongs to (itself for a branch root). */
+  readonly branch: LevelName<S>;
+  /** The level columns' db-column metadata, keyed by field, in order. */
+  readonly levelColumns: Readonly<Record<string, DbColumn>>;
+  /** A leaf's own domain columns, keyed by field, in order; empty for a marker. */
+  readonly leafColumns: Readonly<Record<string, DbColumn>>;
+}
+/**
+ * The type-level column metadata of one level: its level columns' and its
+ * leaf's `DbColumn` maps, recovered from the declaration's phantoms. What a
+ * table derivation reads to type the tables it builds.
+ */
+interface LevelColumnsMeta {
+  readonly level: object;
+  readonly leaf: object;
+}
+/** The default column metadata of a declaration `S`: untyped maps per level. */
+type AnyTreeColumnsMeta<S> = { readonly [K in keyof S]: LevelColumnsMeta; };
+declare const TreeColumnsTypeId: unique symbol;
+/**
+ * A checked tree: the declaration plus every level's derived facts. `M` is a
+ * type-only phantom (never present at runtime) carrying each level's typed
+ * column metadata, so the table derivation types every table it builds.
+ */
+interface Tree<S, M = AnyTreeColumnsMeta<S>> {
+  /** Type-only: each level's typed column metadata. */
+  readonly [TreeColumnsTypeId]?: M;
+  /** The declaration exactly as written, for type-level consumers. */
+  readonly spec: S;
+  /** Every level name, in declaration order. */
+  readonly names: ReadonlyArray<LevelName<S>>;
+  /** Every level, in declaration order. */
+  readonly levels: ReadonlyArray<TreeLevel<S>>;
+  /** The leaf names, in declaration order. */
+  readonly leaves: ReadonlyArray<LeafName<S>>;
+  /** The branch roots (children of the root), in declaration order. */
+  readonly branchRoots: ReadonlyArray<LevelName<S>>;
+  /** Look a level up by name. */
+  readonly level: (name: LevelName<S>) => TreeLevel<S>;
+}
+/**
+ * A referential action for a derived foreign-key column — the Drizzle
+ * `onDelete` / `onUpdate` vocabulary, restated as plain data so the annotation
+ * layer stays Drizzle-free.
+ */
+type ReferentialAction = "cascade" | "restrict" | "no action" | "set null" | "set default";
+/**
+ * Reference / foreign-key metadata a column annotation may carry: the target
+ * relation + column the derived column foreign-keys to, plus its referential
+ * actions. Expressed as **names** (not Drizzle column thunks) so it survives in
+ * the Drizzle-free annotation layer; the derivation resolves the names to real
+ * columns via its own `resolveReference` hook (see the {@link ./derive.ts}
+ * entry).
+ *
+ * This is the metadata that lets an FK-backed attribute be derived rather than
+ * hand-authored as a table-only `references()` column and re-stated in the
+ * consuming application's operation value map.
+ */
+interface DbColumnReference {
+  /** The referenced relation (table) name. */
+  readonly table: string;
+  /** The referenced column name. */
+  readonly column: string;
+  /** Referential action on delete of the referenced row. */
+  readonly onDelete?: ReferentialAction | undefined;
+  /** Referential action on update of the referenced row. */
+  readonly onUpdate?: ReferentialAction | undefined;
+}
+/**
+ * Column metadata a model attribute declares about the column it backs. Generic
+ * over the column-kind union `Kind` (open `string` by default) — a consumer pins
+ * it to its own kinds via {@link dbColumnFor}.
+ */
+interface DbColumn<Kind extends string = string> {
+  /** The snake_case column name (e.g. `published_at`). */
+  readonly column: string;
+  /** The column kind (selects the Drizzle builder in the derivation). */
+  readonly pg: Kind;
+  /** Whether the column is `NOT NULL`. */
+  readonly notNull: boolean;
+  /** Optional SQL `DEFAULT`. */
+  readonly default?: boolean | number | string | undefined;
+  /** Optional foreign-key metadata (see {@link DbColumnReference}). */
+  readonly references?: DbColumnReference | undefined;
+  /**
+   * Optional explicit name for the CHECK constraint the column's numeric
+   * bounds derive — a migration-compat escape hatch for keeping a historical
+   * constraint name where the canonical `${table}_${column}_${suffix}` would
+   * rename it. Omit for new columns.
+   */
+  readonly checkName?: string | undefined;
+}
+/**
+ * The annotation key under which {@link dbColumn} stores its metadata.
+ * {@link dbColumn} writes it; {@link readDbColumn} and {@link fieldColumns}
+ * read it. Namespaced to the package so a consumer's own annotations never
+ * collide.
+ */
+declare const DB_COLUMN_KEY = "effect-drizzle-ext/dbColumn";
+declare const DbColumnTypeId: unique symbol;
+/**
+ * A schema carrying db-column metadata `M` in a type-level phantom (the
+ * annotation value itself is erased from the type, so the phantom is what keeps
+ * the derived column map precise). The phantom property is **required for type
+ * matching** — a non-annotated schema must yield `never`, not `unknown`, so the
+ * column derivation can tell columns from plain / computed fields — but it is
+ * never present at runtime (the runtime reads the real annotation instead).
+ */
+type Annotated<S extends Schema.Top, M extends DbColumn> = S & {
+  readonly [DbColumnTypeId]: M;
+};
+/** Recovers the db-column metadata phantom from a schema, or `never`. */
+type DbColumnOf<S> = S extends {
+  readonly [DbColumnTypeId]: infer M extends DbColumn;
+} ? M : never;
+/**
+ * Annotate a base schema with the database column it backs. Attaches a genuine
+ * Effect annotation (the runtime reads it via {@link readDbColumn}) and carries
+ * the metadata literally in the type (so the column derivation stays precisely
+ * typed). Wrap the result in a model helper as usual — the helper's projection
+ * carries the annotation through to the table factory.
+ *
+ * Accepts any `pg` string; pin the kind union with {@link dbColumnFor} to catch
+ * unknown-kind typos at the annotation site.
+ */
+declare const dbColumn: <S extends Schema.Top, const M extends DbColumn>(schema: S, meta: M) => Annotated<S, M>;
+/**
+ * A {@link dbColumn} constrained to a specific column-kind union `Kind`. A
+ * consumer pins its own kinds once — `const dbColumn = dbColumnFor<PgKind>()` —
+ * so an annotation naming a kind the derivation can't build is a type error at
+ * the annotation site rather than a runtime surprise.
+ */
+declare const dbColumnFor: <Kind extends string>() => <S extends Schema.Top, const M extends DbColumn<Kind>>(schema: S, meta: M) => Annotated<S, M>;
+/**
+ * Read the db-column annotation off a schema at runtime. `Option.none()` when
+ * the schema declares none.
+ *
+ * Reads the schema's **own** annotations only: `Schema.resolveAnnotations` on a
+ * `Schema.optional(...)` / `Schema.NullOr(...)` wrapper does not see the inner
+ * schema's annotation. Use {@link fieldColumns} for a struct's fields, which
+ * peels those wrappers structurally.
+ */
+declare const readDbColumn: (schema: Schema.Constraint) => Option.Option<DbColumn>;
+/**
+ * The base table metadata {@link dbTable} attaches: the SQL leaf name the
+ * annotated target backs (a versioned consumer's version table is
+ * `${name}_version`).
+ *
+ * `TableMeta` is the floor, not the whole vocabulary: {@link dbTable} accepts
+ * any `TableMeta`, so a **flat** consumer — one whose tables anchor at no
+ * hierarchy at all — annotates with `{ name }` and nothing else, instead of
+ * re-implementing `dbTable` locally just to drop a field it has no use for.
+ * A level-dispatching consumer pins {@link DbTable} via {@link dbTableFor}.
+ */
+interface TableMeta {
+  /** The snake_case leaf table name (e.g. `podcast_series`). */
+  readonly name: string;
+}
+/**
+ * Table metadata that additionally names the hierarchy level the leaf anchors
+ * at (selecting the parent table pair in a level-dispatching consumer). Generic
+ * over the level union `Level` (open `string` by default) — a consumer pins it
+ * to its own levels via {@link dbTableFor}, so a leaf naming an unknown level is
+ * a type error at the annotation site.
+ */
+interface DbTable<Level extends string = string> extends TableMeta {
+  /** The hierarchy level the leaf anchors at (selects the parent table pair). */
+  readonly level: Level;
+}
+declare const DbTableTypeId: unique symbol;
+/**
+ * A target object carrying db-table metadata `M` in a type-level phantom — the
+ * table-level counterpart of {@link Annotated}. The phantom keeps a consumer's
+ * level dispatch precise (a `"work"`-anchored leaf cannot be passed to a
+ * `"manifestation"` table factory); the runtime reads the real attached
+ * metadata via {@link readDbTable}.
+ */
+type TableAnnotated<T extends object, M extends TableMeta> = T & {
+  readonly [DbTableTypeId]: M;
+};
+/** Recovers the db-table metadata phantom from a target, or `never`. */
+type DbTableOf<T> = T extends {
+  readonly [DbTableTypeId]: infer M extends TableMeta;
+} ? M : never;
+/**
+ * Annotate any object with the database table it backs. Attaches the metadata
+ * as a non-enumerable symbol property (see {@link DB_TABLE_KEY} for why not
+ * `annotate`) and carries it literally in the type, so a level-bound table
+ * factory can constrain its input to leaves anchored at its level. Returns the
+ * **same** object.
+ *
+ * Accepts any {@link TableMeta}; pin a level union with {@link dbTableFor}.
+ */
+declare const dbTable: <T extends object, const M extends TableMeta>(target: T, meta: M) => TableAnnotated<T, M>;
+/**
+ * A {@link dbTable} constrained to a specific level union `Level`, requiring the
+ * full {@link DbTable} metadata. A consumer pins its own levels once — `const
+ * dbTable = dbTableFor<LeafLevel>()` — so an annotation naming a level the
+ * derivation has no parent binding for is a type error at the annotation site
+ * rather than a runtime surprise.
+ */
+declare const dbTableFor: <Level extends string>() => <T extends object, const M extends DbTable<Level>>(target: T, meta: M) => TableAnnotated<T, M>;
+/**
+ * Read the db-table metadata off a target at runtime. `Option.none()` when the
+ * target carries none.
+ *
+ * Typed to the {@link TableMeta} floor: a consumer that annotated with a
+ * {@link DbTable} recovers its `level` through the {@link DbTableOf} phantom,
+ * which is where the level is statically known.
+ */
+declare const readDbTable: <T extends object>(target: T) => Option.Option<TableMeta>;
+/**
+ * Numeric bounds recovered from a schema's checks — the JSON-Schema bound
+ * vocabulary. The source of a derived SQL `CHECK` constraint: one declaration
+ * (the model's `Schema.isGreaterThanOrEqualTo(0)` / `isBetween` check) drives
+ * wire validation **and** the column's database constraint.
+ */
+interface NumericBounds {
+  readonly minimum?: number | undefined;
+  readonly maximum?: number | undefined;
+  readonly exclusiveMinimum?: number | undefined;
+  readonly exclusiveMaximum?: number | undefined;
+}
+/** The bounds of one column-backed attribute, paired with its column metadata. */
+interface ColumnBounds extends NumericBounds {
+  readonly column: DbColumn;
+}
+/**
+ * Recover the {@link NumericBounds} a single attribute schema declares, or
+ * `Option.none()` when it declares none. Reads the schema's own checks plus the
+ * checks of each union member — the `Schema.NullOr(Schema.Finite.check(...))`
+ * shape a nullable numeric attribute takes. Deliberately shallow: bounds
+ * buried deeper than one union level are a modelling smell, not a supported
+ * shape.
+ *
+ * Exported because the `./jsonapi` entry's resource-level bounds reader is the
+ * same walk over a different field source.
+ */
+declare const numericBounds: (schema: Schema.Constraint) => Option.Option<NumericBounds>;
+/**
+ * Peels the `Schema.optional(...)` / `Schema.optionalKey(...)` /
+ * `Schema.NullOr(...)` / `Schema.UndefinedOr(...)` wrappers a model attribute
+ * applies, to reach a {@link dbColumn}-annotated base schema's phantom, or
+ * `never`. A required attribute carries the annotation on its base schema
+ * directly (no peel); an optional / nullable projection wraps it.
+ *
+ * The wrapper set mirrors what {@link fieldColumns} peels at runtime — note
+ * that `Schema.optional(S)` *is* `optionalKey(UndefinedOr(S))`, so the two pairs
+ * are one chain, not four independent cases.
+ */
+type UnwrapColumn<S> = [DbColumnOf<S>] extends [never] ? [S] extends [Schema.optional<infer Inner>] ? UnwrapColumn<Inner> : [S] extends [Schema.optionalKey<infer Inner>] ? UnwrapColumn<Inner> : [S] extends [Schema.NullOr<infer Inner>] ? UnwrapColumn<Inner> : [S] extends [Schema.UndefinedOr<infer Inner>] ? UnwrapColumn<Inner> : never : DbColumnOf<S>;
+/**
+ * The db-column metadata map a `Schema.Struct`'s fields project to, keyed by the
+ * fields that declare a {@link dbColumn} (others drop out of the map entirely).
+ * The type-level counterpart of {@link fieldColumns}.
+ */
+type FieldColumnsMetaOf<F extends Schema.Struct.Fields> = { readonly [K in keyof F as [UnwrapColumn<F[K]>] extends [never] ? never : K]: UnwrapColumn<F[K]>; };
+/**
+ * Project a `Schema.Struct`'s fields to the per-field {@link DbColumn} metadata
+ * the derivation consumes, dropping fields that declare no column. Peels the
+ * `optional` / `NullOr` wrappers a field may apply. The type-level counterpart
+ * is {@link FieldColumnsMetaOf}.
+ */
+declare const fieldColumns: (fields: Schema.Struct.Fields) => Record<string, DbColumn>;
+/**
+ * Project a `Schema.Struct`'s per-field numeric bounds into plain data a
+ * `CHECK`-constraint derivation consumes: for each {@link dbColumn}-annotated
+ * field whose schema carries numeric-bound checks, the bounds paired with the
+ * column metadata. Fields without a column, or without bounds, drop. The
+ * Drizzle-emitting counterpart is the `./derive` entry's
+ * `deriveFieldCheckConstraints`.
+ */
+declare const fieldColumnBounds: (fields: Schema.Struct.Fields) => Record<string, ColumnBounds>;
+/** The fields an entry's member `K` (`columns` or `leaf`) declares; `{}` when absent. */
+type EntryFields<E, K extends "columns" | "leaf"> = E extends { readonly [P in K]?: infer F; } ? Exclude<F, undefined> extends Schema.Struct.Fields ? Exclude<F, undefined> : Record<never, never> : Record<never, never>;
+/**
+ * The typed column metadata of a {@link defineTree} declaration `S`: per level,
+ * the `DbColumn` maps its level columns and its leaf fields carry. The phantom
+ * a `Tree` built by `defineTree` holds for the table derivation.
+ */
+type FieldsTreeMeta<S> = { readonly [K in keyof S]: {
+  readonly level: FieldColumnsMetaOf<EntryFields<S[K], "columns">>;
+  readonly leaf: FieldColumnsMetaOf<EntryFields<S[K], "leaf">>;
+}; };
+/**
+ * A {@link defineTree} whose every entry also carries the consumer's
+ * extension record `Ext` (pulpit's `owned` / `pageable` flags, say); the
+ * library reads none of its members and hands each entry back on
+ * `tree.level(name).entry`. Pin it once — `const defineTree =
+ * defineTreeFor<RegistryFlags>()` — so an entry missing a flag is a type
+ * error. Throws {@link DerivationError} at module load as `defineTree` does.
+ */
+declare const defineTreeFor: <Ext extends object>() => <const S extends CheckedTreeSpec<S, Schema.Struct.Fields, Ext>>(spec: S) => Tree<S, FieldsTreeMeta<S>>;
+/**
+ * Declare an ontology's level tree once, Drizzle-free, so a models package can
+ * state it and the database layer derive every table, constraint and view from
+ * it. Each entry is a level: a **marker** (no `leaf`) or a **leaf**, whose
+ * `leaf` is the struct fields of its domain columns (`dbColumn`-annotated) and
+ * whose name is its discriminator value. An entry names its `parent` (absent:
+ * a branch root under the tree's root), and may carry level `columns`
+ * contributed to every descendant's view and a level `kind`.
+ *
+ * Returns the checked {@link Tree}: per level, its ancestors, children,
+ * descendants, subtree leaves (the discriminator CHECK value set) and branch,
+ * all in declaration order. A parent naming no level of the tree, or the level
+ * itself, is a type error. Throws {@link DerivationError} at module load for
+ * every structural fault the types can't catch: a missing parent or a cycle, a
+ * leaf with children, a marker with no leaf below it, an unannotated level
+ * column, a reserved column name (`id`, `version`, `action`, `type`), or two
+ * columns on one root-to-leaf path sharing a field key or a column name.
+ *
+ * @example
+ * ```ts
+ * import { dbColumn, defineTree } from "@thomasfosterau/effect-drizzle-ext";
+ * import * as Schema from "effect/Schema";
+ *
+ * const tree = defineTree({
+ *   work: {
+ *     columns: { title: dbColumn(Schema.String, { column: "title", pg: "text", notNull: true }) },
+ *   },
+ *   book: {
+ *     parent: "work",
+ *     leaf: { pages: dbColumn(Schema.Finite, { column: "pages", pg: "integer", notNull: false }) },
+ *   },
+ *   film: { parent: "work", leaf: {} },
+ * });
+ *
+ * console.log(tree.level("work").subtreeLeaves); // ["book", "film"]
+ * console.log(tree.level("book").ancestors); // ["work"]
+ * ```
+ */
+declare const defineTree: <const S extends CheckedTreeSpec<S, Schema.Struct.Fields, Record<never, never>>>(spec: S) => Tree<S, FieldsTreeMeta<S>>;
+export { LevelColumnsMeta as A, fieldColumns as C, AnyTreeColumnsMeta as D, readDbTable as E, Tree as F, TreeLevel as I, DerivationError as L, LevelName as M, LevelSpec as N, CheckedTreeSpec as O, MarkerName as P, fieldColumnBounds as S, readDbColumn as T, dbColumnFor as _, DbColumnOf as a, defineTree as b, DbTableOf as c, NumericBounds as d, ReferentialAction as f, dbColumn as g, UnwrapColumn as h, DbColumn as i, LevelKind as j, LeafName as k, FieldColumnsMetaOf as l, TableMeta as m, ColumnBounds as n, DbColumnReference as o, TableAnnotated as p, DB_COLUMN_KEY as r, DbTable as s, Annotated as t, FieldsTreeMeta as u, dbTable as v, numericBounds as w, defineTreeFor as x, dbTableFor as y };
+//# sourceMappingURL=index-CFhgcF4N.d.ts.map

package/dist/index-CFhgcF4N.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-CFhgcF4N.d.ts","names":[],"sources":["../src/derivation-error.ts","../src/tree.ts","../src/index.ts"],"mappings":"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"}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+import { A as LevelColumnsMeta, C as fieldColumns, D as AnyTreeColumnsMeta, E as readDbTable, F as Tree, I as TreeLevel, L as DerivationError, M as LevelName, N as LevelSpec, O as CheckedTreeSpec, P as MarkerName, S as fieldColumnBounds, T as readDbColumn, _ as dbColumnFor, a as DbColumnOf, b as defineTree, c as DbTableOf, d as NumericBounds, f as ReferentialAction, g as dbColumn, h as UnwrapColumn, i as DbColumn, j as LevelKind, k as LeafName, l as FieldColumnsMetaOf, m as TableMeta, n as ColumnBounds, o as DbColumnReference, p as TableAnnotated, r as DB_COLUMN_KEY, s as DbTable, t as Annotated, u as FieldsTreeMeta, v as dbTable, w as numericBounds, x as defineTreeFor, y as dbTableFor } from "./index-CFhgcF4N.js";
+export { Annotated, type AnyTreeColumnsMeta, type CheckedTreeSpec, ColumnBounds, DB_COLUMN_KEY, DbColumn, DbColumnOf, DbColumnReference, DbTable, DbTableOf, DerivationError, FieldColumnsMetaOf, FieldsTreeMeta, type LeafName, type LevelColumnsMeta, type LevelKind, type LevelName, type LevelSpec, type MarkerName, NumericBounds, ReferentialAction, TableAnnotated, TableMeta, type Tree, type TreeLevel, UnwrapColumn, dbColumn, dbColumnFor, dbTable, dbTableFor, defineTree, defineTreeFor, fieldColumnBounds, fieldColumns, numericBounds, readDbColumn, readDbTable };

package/dist/index.js

@@ -0,0 +1 @@
+export { t as DB_COLUMN_KEY, h as DerivationError, n as dbColumn, r as dbColumnFor, i as dbTable, a as dbTableFor, o as defineTree, s as defineTreeFor, c as fieldColumnBounds, l as fieldColumns, u as numericBounds, d as readDbColumn, f as readDbTable } from "./src-CBeuhy5b.js";

package/dist/jsonapi/derive.d.ts

@@ -0,0 +1,28 @@
+import { ColumnBuilders, DeriveOptions, DerivedColumns } from "../derive.js";
+import { AnyResource, ResourceColumnsMetaOf } from "./index.js";
+import { ExtraConfigColumn, PgTableExtraConfigValue } from "drizzle-orm/pg-core";
+/**
+ * The Drizzle column builders a `Resource.make` definition's annotated
+ * attributes produce against registry `B`, keyed and typed per attribute.
+ */
+export type DerivedResourceColumns<R extends AnyResource, B extends ColumnBuilders> = DerivedColumns<ResourceColumnsMetaOf<R>, B>;
+/**
+ * Build a `deriveResourceColumns` bound to a specific builder registry. The
+ * returned function interprets a `Resource.make` definition's per-attribute
+ * `dbColumn` annotations into the Drizzle column builders a table factory's
+ * `columns` expects.
+ */
+export declare const makeDeriveResourceColumns: <B extends ColumnBuilders>(builders: B, options?: DeriveOptions) => (<R extends AnyResource>(resource: R) => DerivedResourceColumns<R, B>);
+/**
+ * Derive the SQL `CHECK` constraints a resource definition's numeric-bound
+ * checks imply, named `${tableName}_${column}_${suffix}` unless the annotation
+ * pins a `checkName`, and guarded with `col IS NULL OR …` for a nullable
+ * column. Returns a callback shaped for a table factory's `extraConstraints`
+ * seam; a bounded attribute whose column is absent from the table throws
+ * {@link DerivationError}.
+ *
+ * The projection is deferred to the returned callback, so this composes inside
+ * a `pgTable(...)` call whose columns are still being assembled.
+ */
+export declare const deriveCheckConstraints: (resource: AnyResource, tableName: string) => (table: Record<string, ExtraConfigColumn>) => PgTableExtraConfigValue[];
+//# sourceMappingURL=derive.d.ts.map

package/dist/jsonapi/derive.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"derive.d.ts","names":[],"sources":["../../src/jsonapi/derive.ts"],"mappings":";;;;;;;YAqCY,uBACV,UAAU,aACV,UAAU,kBACR,eAAe,sBAAsB,IAAI;;;;;;;qBAQhC,4BAA6B,UAAU,gBAAc,UACtD,GAAC,UACF,oBACN,UAAU,aAAa,UAAU,MAAM,uBAAuB,GAAG;;;;;;;;;;;;qBAmBzD,yBAAsB,UACtB,aAAW,uBAAmB,OACjC,eAAe,uBAAqB"}

package/dist/jsonapi/derive.js

@@ -0,0 +1,28 @@
+import { deriveCheckConstraintsFrom, makeDeriveColumns } from "../derive.js";
+import { resourceColumnBounds, resourceColumns } from "./index.js";
+// src/jsonapi/derive.ts
+/**
+* Build a `deriveResourceColumns` bound to a specific builder registry. The
+* returned function interprets a `Resource.make` definition's per-attribute
+* `dbColumn` annotations into the Drizzle column builders a table factory's
+* `columns` expects.
+*/
+const makeDeriveResourceColumns = (builders, options = {}) => {
+	const derive = makeDeriveColumns(builders, options);
+	return (resource) => derive.fromMeta(resourceColumns(resource));
+};
+/**
+* Derive the SQL `CHECK` constraints a resource definition's numeric-bound
+* checks imply, named `${tableName}_${column}_${suffix}` unless the annotation
+* pins a `checkName`, and guarded with `col IS NULL OR …` for a nullable
+* column. Returns a callback shaped for a table factory's `extraConstraints`
+* seam; a bounded attribute whose column is absent from the table throws
+* {@link DerivationError}.
+*
+* The projection is deferred to the returned callback, so this composes inside
+* a `pgTable(...)` call whose columns are still being assembled.
+*/
+const deriveCheckConstraints = (resource, tableName) => (table) => deriveCheckConstraintsFrom(resourceColumnBounds(resource), tableName)(table);
+export { deriveCheckConstraints, makeDeriveResourceColumns };
+
+//# sourceMappingURL=derive.js.map

package/dist/jsonapi/derive.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"derive.js","names":[],"sources":["../../src/jsonapi/derive.ts"],"mappings":";;;;;;;;;AAgDA,MAAa,6BACX,UACA,UAAyB,CAAC,MACiD;CAC3E,MAAM,SAAS,kBAAkB,UAAU,OAAO;CAClD,QAA+B,aAG7B,OAAO,SAAS,gBAAgB,QAAQ,CAAC;AAC7C;;;;;;;;;;;;AAaA,MAAa,0BACV,UAAuB,eACvB,UACC,2BAA2B,qBAAqB,QAAQ,GAAG,SAAS,CAAC,CAAC,KAAK"}