joist-core 2.3.0 → 2.4.0

package/build/queries/sql/Tables.d.mts

@@ -0,0 +1,322 @@
+import { ColumnsOf, FieldsOf, FilterOf, TypeMap, TypeNameOf } from "../../typeMap.mjs";
+import { SqlCondition } from "../conditions.mjs";
+import { EntityMetadata } from "../../EntityMetadata.mjs";
+import { CustomColumnInputs, CustomTable, CustomTableDefinition, CustomTableFor, CustomTableMgmt } from "./custom.mjs";
+import { QueryArg, QueryJoinInput, QuerySource } from "./query.mjs";
+import { BaseExpr, Expr, ExprLike, InnerJoin, LeftJoin, selectKeyBrand } from "./Expr.mjs";
+import { IdOf, MaybeAbstractEntityConstructor, TaggedId } from "../../EntityManager.mjs";
+import { Entity } from "../../Entity.mjs";
+//#region src/queries/sql/Tables.d.ts
+/** Creates physical column expressions and relationship joins for `T`. */
+declare function table<T extends Entity>(cstr: MaybeAbstractEntityConstructor<T>): Table<T>;
+/** Creates a typed physical handle for a table declared with `declareTable`. */
+declare function table<TableName extends string, C extends CustomColumnInputs>(definition: CustomTableDefinition<TableName, C>): CustomTable<C, TableName>;
+/**
+ * Creates a table with an explicit type-level name, i.e. `table(Author, "m")` for a self-join.
+ *
+ * The name is the table's source key in `em.query`: two bare `table(Author)`s share the key `"Author"`,
+ * so a left-joined mentor would also mark the mentee's columns nullable; a named alias has its own key.
+ */
+declare function table<T extends Entity, Name extends string>(cstr: MaybeAbstractEntityConstructor<T>, name: Name): Table<T, Name>;
+/** Creates a named custom-table handle for joins and self-joins. */
+declare function table<C extends CustomColumnInputs, TableName extends string, Name extends string>(definition: CustomTableDefinition<TableName, C>, name: Name): CustomTable<C, Name>;
+/** Creates multiple physical table handles. */
+declare function tables<T extends readonly MaybeAbstractEntityConstructor<any>[]>(...type: T): { [P in keyof T]: T[P] extends MaybeAbstractEntityConstructor<infer E extends Entity> ? Table<E> : never; };
+/**
+ * The runtime management interface plus phantom type information for `em.query`.
+ *
+ * `__entity` lets `QueryRow` recover `T` for entity mode (you cannot `infer T` back out of a mapped
+ * type), and `__name` is the table's source key (see `Expr`).
+ */
+interface TableSourceBrand<Name extends string> extends TableSourceMgmt {
+  readonly __name: Name;
+}
+/** A modeled table source that can hydrate its generated entity type. */
+interface TableBrand<T, Name extends string> extends TableSourceBrand<Name>, TableMgmt {
+  readonly __entity: T;
+}
+/**
+ * A physical table for `T`: one expression per SQL column, with relationship names as join factories.
+ * Selecting the table itself retains entity hydration; selecting columns returns decoded SQL values.
+ *
+ * Unlike an Alias, a Table is an explicit SQL source, not a place to bind in an em.find relationship
+ * tree. I.e. with `a = table(Author)`, `{ from: a }` registers that handle in the query's scope.
+ * Its columns already know their physical column and codec, but their SQL name still depends on the
+ * query: the same Author handle might be `a` in one query and `a1` in a nested query.
+ *
+ * Each predicate occurrence renders through ExprContext.aliasFor using the current scope (or an
+ * enclosing scope for a correlation). Rendering returns SQL, ordered bindings, and source references
+ * together. A comparison records both sides' references; templates and subqueries carry their
+ * references too. Join pruning follows these references and join dependencies, rather than guessing
+ * which tables a SQL string mentions. It also accounts for select/order/group expressions and keep.
+ *
+ * I.e. if a joined Author is used only by `a.firstName.eq(name)`, supplying undefined removes that
+ * predicate and lets the unused join prune. Both APIs share this undefined-condition pruning rule;
+ * they differ in how they get the references: Alias resolves domain conditions against a relationship
+ * tree, while Table renders SQL expressions against explicit sources. Neither caches SQL names on
+ * the reusable handle or predicate, so one parse cannot overwrite another parse's bindings.
+ *
+ * `Name` is the table's type-level source key, defaulting to the entity's own type name, so a
+ * LEFT-joined SmallPublisher does not make Publisher columns nullable. `table(Author, "m")`
+ * gives a self-join table its own key.
+ */
+type Table<T extends Entity, Name extends string = TableNameOf<T>> = TableShape<T, Name> & ("where" extends keyof TableShape<T, Name> ? {} : {
+  /** Builds an AND condition from local domain fields, without implicit joins. */
+  where(filter: TableFilter<T>): SqlCondition;
+}) & ("column" extends keyof TableShape<T, Name> ? {} : {
+  /**
+   * References a column Joist does not model, i.e. `a.column<string>("ts_search")`.
+   *
+   * The expression keeps this table's source key, so it is scope-checked and nullified by a
+   * LEFT join like any modeled column. `R` is unchecked: it asserts what the database returns,
+   * and the value is not decoded through a codec.
+   *
+   * A schema that has its own `column` column or relation keeps that meaning, and then has no
+   * escape hatch for unmodeled columns.
+   */
+  column<R = unknown>(column: string): Expr<R, Name>;
+});
+/** Domain filters for fields stored on this physical table, without relationship traversal. */
+type TableFilter<T extends Entity> = { [K in LocalFieldNames<T> & keyof FieldsOf<T>]?: FieldsOf<T>[K] extends {
+  kind: "m2o";
+  type: infer U extends Entity;
+  nullable: infer N;
+} ? TableReferenceFilter<U, N extends undefined ? null : never> : FilterOf<T>[K]; };
+/** Generated column ownership excludes CTI base fields and polymorphic components. */
+type LocalFieldNames<T> = ColumnsOf<T>[keyof ColumnsOf<T>] extends {
+  fieldName: infer F;
+} ? Extract<F, keyof FilterOf<T>> : never;
+/** The owning-reference subset of find filters that only compares a foreign key. */
+type TableReferenceFilter<T extends Entity, N> = T | IdOf<T> | readonly (T | IdOf<T>)[] | boolean | N | undefined | {
+  ne: T | IdOf<T> | N | undefined;
+};
+/** Maps an entity's columns and relationships to expressions and joins for one typed table handle. */
+type TableShape<T extends Entity, Name extends string> = {
+  readonly [tableMgmt]: TableBrand<T, Name>;
+} & { [P in keyof ColumnsOf<T> & string]: P extends "id" ? EntityColumn<T, never, Name, P> : ColumnsOf<T>[P] extends {
+  entity: infer U extends Entity;
+  nullable: infer N;
+} ? ReferenceColumn<U, N extends true ? null : never, Name, P> : ColumnsOf<T>[P] extends {
+  type: infer V;
+  nullable: infer N;
+} ? PrimitiveColumn<V, N extends true ? null : never, Name, P> : never; } & { [P in keyof FieldsOf<T> as P extends keyof ColumnsOf<T> ? never : FieldsOf<T>[P] extends {
+  kind: "m2o" | "poly" | "o2m" | "lo2m" | "m2m" | "o2o";
+} ? P : never]: FieldsOf<T>[P] extends {
+  kind: "m2o";
+  type: infer U extends Entity;
+  nullable: infer N;
+} ? ReferenceJoin<U, N extends undefined ? null : never, Name> : FieldsOf<T>[P] extends {
+  kind: "poly";
+  type: infer U extends Entity;
+  nullable: infer N;
+} ? PolyReference<U, N extends undefined ? null : never, Name> : FieldsOf<T>[P] extends {
+  kind: "o2m" | "lo2m" | "m2m" | "o2o";
+  type: infer U extends Entity;
+} ? CollectionJoin<U> : never; } & { [K in keyof TypeMap as TypeMap[K] extends {
+  entityType: infer U extends Entity & {
+    __type: {
+      0: TypeNameOf<T>;
+      1: string;
+    };
+  };
+} ? Uncapitalize<TypeNameOf<U> & string> : never]: TypeMap[K] extends {
+  entityType: infer U extends Entity;
+} ? SubtypeJoin<U> : never; };
+/** Keeps explicit base and subtype sources independent, with generic entities untracked. */
+type TableNameOf<T> = T extends {
+  __type: {
+    0: string;
+  };
+} ? TypeNameOf<T> & string : string;
+/** Provides fluent methods for creating joins through an owning reference relationship. */
+interface ReferenceJoin<U extends Entity, N extends null | never, Src extends string = string> {
+  /**
+   * Required reference joins like `b.author.as(a)` are INNER unless `b` is already a LEFT-joined alias.
+   * Nullable references are always LEFT joined.
+   */
+  as<A extends TableFor<U>>(other: A): [N] extends [never] ? DefaultReferenceJoin<A, Src> : LeftJoin<A>;
+  inner<A extends TableFor<U>>(other: A): InnerJoin<A>;
+  left<A extends TableFor<U>>(other: A): LeftJoin<A>;
+}
+/** The source of a default reference join, used to inherit optional paths within each query. */
+declare const referenceJoinSource: unique symbol;
+/** A required reference defaults to INNER unless its source was LEFT joined. */
+type DefaultReferenceJoin<A, Src extends string> = InnerJoin<A> & {
+  readonly [referenceJoinSource]: Src;
+};
+/** Any table whose entity is (a subtype of) `U`, i.e. what a relation join factory accepts. */
+type TableFor<U> = {
+  readonly [tableMgmt]: TableBrand<U, string>;
+};
+/**
+ * A collection relation (o2m/o2o/m2m) as a join factory: `a.books.as(b)` returns the same
+ * `{ left: b, on: ... }` entry the expanded form writes, with the FK condition built from metadata, so
+ * join-list inference, nullability, scope checking, and pruning are unchanged and both forms mix freely.
+ *
+ * `as` binds the joined alias, the same way em.find's `{ books: { as: b } }` does. The default is LEFT
+ * (a collection may be empty, and a LEFT join never filters rows, so pruning it is always safe);
+ * `.inner(b)` opts into filtering. An m2m entry carries a hidden second join through the join table,
+ * which the parser expands; the pair prunes together.
+ */
+interface CollectionJoin<U extends Entity> {
+  as<A extends TableFor<U>>(other: A): LeftJoin<A>;
+  inner<A extends TableFor<U>>(other: A): InnerJoin<A>;
+  left<A extends TableFor<U>>(other: A): LeftJoin<A>;
+}
+/** A named subtype join, defaulting to LEFT because a root row may belong to another subtype. */
+interface SubtypeJoin<U extends Entity> extends CollectionJoin<U> {
+  <A extends TableFor<U>>(other: A): LeftJoin<A>;
+}
+/**
+ * A physical FK column expression (`b.authorId` selects/compares the `author_id` FK) plus a join factory
+ * (`b.authorId.as(a)` joins). The default join kind follows physical column nullability:
+ * a NOT NULL FK is INNER unless its source was LEFT joined, a nullable one is LEFT, and the row type reflects it.
+ */
+interface ReferenceColumn<U extends Entity, N extends null | never, Src extends string, Key extends string = string> extends EntityColumn<U, N, Src, Key>, ReferenceJoin<U, N, Src> {}
+/**
+ * A polymorphic reference: condition methods (each resolving the component column from the value), plus
+ * a join factory that picks the component from the argument's entity, i.e. `c.parent.as(a)` joins
+ * through `parent_author_id`, like an explicit join with `on: c.parent.eq(a.id)`.
+ */
+interface PolyReference<U extends Entity, N extends null | never, Src extends string = string> extends ReferenceJoin<U, N, Src> {
+  eq(value: U | TaggedId | ExprLike<IdOf<U> | null> | null | undefined): SqlCondition;
+  ne(value: U | TaggedId | ExprLike<IdOf<U> | null> | null | undefined): SqlCondition;
+  in(values: readonly (U | TaggedId)[] | ExprLike<IdOf<U> | null> | undefined): SqlCondition;
+  /** Applies an IN condition unless the list is empty or undefined. */
+  inNonEmpty(values: readonly (U | TaggedId)[] | undefined): SqlCondition;
+}
+interface PrimitiveColumn<V, N extends null | never, Src extends string = string, Key extends string = string> extends Expr<V | N, Src> {
+  readonly [selectKeyBrand]: Key;
+  eq(value: V | ExprLike<V | N> | N | undefined): SqlCondition;
+  ne(value: V | ExprLike<V | N> | N | undefined): SqlCondition;
+  in(values: readonly (V | null)[] | ExprLike<V | null> | undefined): SqlCondition;
+  /** Applies an IN condition unless the list is empty or undefined. */
+  inNonEmpty(values: readonly (V | null)[] | undefined): SqlCondition;
+  nin(values: readonly (V | null)[] | ExprLike<V | null> | undefined): SqlCondition;
+  gt(value: V | ExprLike<V | N> | undefined): SqlCondition;
+  gte(value: V | ExprLike<V | N> | undefined): SqlCondition;
+  lt(value: V | ExprLike<V | N> | undefined): SqlCondition;
+  lte(value: V | ExprLike<V | N> | undefined): SqlCondition;
+  like(value: V | undefined): SqlCondition;
+  ilike(value: V | undefined): SqlCondition;
+  search(value: V | undefined): SqlCondition;
+  between(v1: V | undefined, v2: V | undefined): SqlCondition;
+  contains(value: string | V | PrimitiveColumn<V, any> | N | undefined): SqlCondition;
+  ncontains(value: string | V | PrimitiveColumn<V, any> | N | undefined): SqlCondition;
+  overlaps(value: V | PrimitiveColumn<V, any> | N | undefined): SqlCondition;
+  noverlaps(value: V | PrimitiveColumn<V, any> | N | undefined): SqlCondition;
+  /**
+   * Adds a JSON path existence condition, using the `@?` operator.
+   *
+   * Any values should be embedded directly within the `jsonPath`, because postgres does not
+   * support parameterized JSON path expressions. The entire `jsonPath` is treated as a parameter,
+   * so this is safe from SQL injection.
+   */
+  pathExists(jsonPath: string | undefined): SqlCondition;
+  /**
+   * Adds a JSON path predicate condition, using the `@@` operator.
+   *
+   * Any values should be embedded directly within the `jsonPath`, because postgres does not
+   * support parameterized JSON path expressions. The entire `jsonPath` is treated as a parameter,
+   * so this is safe from SQL injection.
+   */
+  pathIsTrue(jsonPath: string | undefined): SqlCondition;
+  /**
+   * Add `exp` to the query, which should include the operator & expression and any
+   * bound parameters (but not include the column name).
+   *
+   * We use knex-style placeholders, i.e. `?` and `\\?` to escape question marks, i.e.
+   *
+   * ```ts
+   * a.address.raw("@\\? ?", ['$.street ? (@ == "rr2")'])`
+   * ```
+   */
+  raw(exp: string, bindings: readonly any[] | undefined): SqlCondition;
+}
+interface EntityColumn<T, N extends null | never = never, Src extends string = string, Key extends string = string> extends Expr<IdOf<T> | N, Src> {
+  readonly [selectKeyBrand]: Key;
+  /** Produces the tagged ID as SQL text, preserving NULL and the column's source. */
+  taggedId(): Expr<string | N, Src>;
+  eq(value: T | IdOf<T> | ExprLike<IdOf<T> | null> | null | undefined): SqlCondition;
+  ne(value: T | IdOf<T> | ExprLike<IdOf<T> | null> | null | undefined): SqlCondition;
+  in<F extends QuerySource, const S extends ExprLike<IdOf<T> | null>, J extends QueryJoinInput = [], Name extends string = "?">(value: QueryArg<F, S, J, Name>): SqlCondition;
+  in(value: readonly (T | IdOf<T> | null)[] | ExprLike<IdOf<T> | null> | null | undefined): SqlCondition;
+  /** Applies an IN condition unless the list is empty, null, or undefined. */
+  inNonEmpty(value: readonly (T | IdOf<T> | null)[] | null | undefined): SqlCondition;
+  nin(value: readonly (T | IdOf<T> | null)[] | ExprLike<IdOf<T> | null> | null | undefined): SqlCondition;
+  gt(value: IdOf<T> | ExprLike<IdOf<T> | null> | null | undefined): SqlCondition;
+  gte(value: IdOf<T> | ExprLike<IdOf<T> | null> | null | undefined): SqlCondition;
+  lt(value: IdOf<T> | ExprLike<IdOf<T> | null> | null | undefined): SqlCondition;
+  lte(value: IdOf<T> | ExprLike<IdOf<T> | null> | null | undefined): SqlCondition;
+  raw(exp: string, bindings: readonly any[] | undefined): SqlCondition;
+}
+declare const tableMgmt: unique symbol;
+declare const inQueryCondition: unique symbol;
+/** Defers a direct IN query literal to query.ts, which owns query pruning and SQL generation. */
+interface InQueryCondition {
+  readonly [inQueryCondition]: {
+    column: BaseExpr;
+    query: object;
+  };
+}
+declare function getTableMgmt<T extends Entity>(table: TableFor<T>): TableMgmt;
+declare function getTableMgmt(table: CustomTableFor): CustomTableMgmt;
+declare function getTableMgmt(table: TableFor<Entity> | CustomTableFor): TableSourceMgmt;
+/** The identity SQL queries bind a table by, plus its original entity metadata. */
+interface TableSourceMgmt {
+  tableName: string;
+  schema?: string;
+}
+/** Qualifies custom tables without changing SQL for tables on the default search path. */
+declare function tableSqlName(table: TableSourceMgmt): string;
+/** The identity and generated metadata of a modeled entity table. */
+interface TableMgmt extends TableSourceMgmt {
+  /**
+   * The metadata this table was created with, i.e. `table(TaskNew)` keeps `taskNewMeta`.
+   *
+   * It cannot be re-derived from `tableName`: STI subtypes share their base's table (`Task`, `TaskNew`,
+   * and `TaskOld` are all `tasks`), so a `getMetadataForTable("tasks")` lookup can only return the base
+   * `Task`, and the alias would lose its subtype identity for explicit subtype joins and entity hydration.
+   */
+  meta: EntityMetadata;
+}
+/** Returns the metadata for the entity that `table` is bound to. */
+declare function getTableMetadata<T extends Entity>(table: TableFor<T>): EntityMetadata<T>;
+declare function newTableProxy<T extends Entity>(cstr: MaybeAbstractEntityConstructor<T>): Table<T>;
+declare function isTable(obj: unknown): obj is Table<any, any> | CustomTableFor;
+/** Whether a physical table has generated entity metadata. */
+declare function isEntityTable(obj: unknown): obj is Table<any, any>;
+/** Whether a physical table has columns declared through `declareTable`. */
+declare function isCustomTable(obj: unknown): obj is CustomTableFor;
+/**
+ * Marks a sugar join entry whose target is a *collection* (o2m/m2m), which filter soft-deletes like
+ * em.find's "collections filter out soft-deletes, but m2o/o2o references still return them"; see
+ * `QueryParser.addSoftDeleteCondition`'s call site. Reference joins and explicit joins are unmarked.
+ */
+declare const collectionJoin: unique symbol;
+/** Marks a sugar m2m join entry (`a.tags.as(t)`) with its hidden join-table join; `parseQuery` expands it. */
+declare const m2mJoinTable: unique symbol;
+interface M2mJoinTable {
+  handle: JoinTableHandle;
+  on: SqlCondition;
+}
+/** The runtime identity of an m2m join table in a query, i.e. `authors_to_tags`; it has no entity. */
+declare class JoinTableHandle {
+  readonly joinTableName: string;
+  constructor(joinTableName: string);
+}
+/**
+ * Maps local domain fields to table-bound conditions, encoding each leaf once.
+ * I.e. Author.firstName uses the first_name column but resolves its alias in each query scope.
+ * Collections, polymorphic references, and inherited nonlocal fields require explicit expressions.
+ */
+declare function tableWhere(mgmt: TableMgmt, filter: object): SqlCondition;
+/**
+ * Converts relationship filters into conditions on the joined table's id column.
+ * I.e. Author's `join: { books: "b:1" }` filters Book.id to 1; `{ books: book }` uses book.id.
+ * Lists match any supplied ID, `true` requires a Book, and `null` or `false` requires no Book.
+ */
+declare function tableEntityWhere(mgmt: TableMgmt, value: unknown): SqlCondition;
+//#endregion
+export { CollectionJoin, DefaultReferenceJoin, EntityColumn, InQueryCondition, JoinTableHandle, M2mJoinTable, PolyReference, PrimitiveColumn, ReferenceColumn, ReferenceJoin, Table, TableBrand, TableFilter, TableFor, TableMgmt, TableSourceBrand, TableSourceMgmt, collectionJoin, getTableMetadata, getTableMgmt, inQueryCondition, isCustomTable, isEntityTable, isTable, m2mJoinTable, newTableProxy, referenceJoinSource, table, tableEntityWhere, tableMgmt, tableSqlName, tableWhere, tables };
+//# sourceMappingURL=Tables.d.mts.map

package/build/queries/sql/Tables.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Tables.d.mts","names":[],"sources":["../../../src/queries/sql/Tables.ts"],"mappings":"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"}