@happyvertical/smrt-core 0.40.69 → 0.41.0

package/dist/schema/generator.d.ts

@@ -1,6 +1,6 @@
 import { FieldDefinition, FieldMeta, ManifestSchema, SmartObjectDefinition, SmartObjectManifest } from '../scanner/types.js';
 import { DatabaseEngine } from './ddl/types.js';
-import { SchemaDefinition } from './types.js';
+import { DeclaredIndexDefinition, SchemaDefinition } from './types.js';
 /**
  * Structural shape of a field as read from either the build-time manifest
  * (`FieldDefinition`) or the runtime ObjectRegistry (`getAllFields()` returns
@@ -25,8 +25,32 @@ interface RegistryField {
     _meta?: FieldMeta;
 }
 type SchemaGeneratorConfig = {
+    /**
+     * The table's resolved conflict target. Registry callers pass
+     * `ObjectRegistry.getConflictColumns()`; the manifest path passes the
+     * object's `decoratorConfig` after `ManifestGenerator.normalizeConflictColumns()`
+     * materialized the tenant-aware default (#2360). When absent, the generator
+     * derives the default itself from `tenantScoped` and the strategy.
+     */
     conflictColumns?: string[];
+    /**
+     * The schema owner's `@smrt({ tenantScoped })` config as the manifest
+     * carries it — consulted only to derive the default conflict target when
+     * `conflictColumns` is absent.
+     */
+    tenantScoped?: boolean | {
+        field?: string;
+    };
     idType?: 'uuid' | 'text';
+    /**
+     * `@smrt({ indexes: [...] })` declarations (#2357).
+     *
+     * The manifest paths receive the whole `decoratorConfig`, so this arrives for
+     * free there. The runtime paths rebuild a narrow config bag by hand
+     * (`schema/utils.ts`, `testing/database.ts`) and must thread it explicitly —
+     * omitting it is what made the option unreachable at runtime.
+     */
+    indexes?: DeclaredIndexDefinition[];
     registry?: {
         getConfig?(className: string): {
             idType?: 'uuid' | 'text';
@@ -55,6 +79,263 @@ export declare class SchemaGenerator {
      * Generate column definitions
      */
     private generateColumns;
+    /**
+     * Whether an existing index already leads with `leadingColumns`, in order.
+     *
+     * Only an UNQUALIFIED index (no partial `WHERE`, no JSON-path expression)
+     * counts. A partial index such as `... WHERE _meta_type = 'Article'` cannot
+     * serve a base-class polymorphic query, which carries no subtype predicate,
+     * so it must not suppress the standalone index (#2359, review of #2384).
+     *
+     * A B-tree serves any prefix of its column list, so an index over
+     * `(tenant_id, created_at, status)` covers both `(tenant_id)` equality
+     * lookups and `(tenant_id, created_at)` ordering — hence the prefix test
+     * rather than an exact match (#2363).
+     */
+    private hasUnqualifiedLeadingColumns;
+    /**
+     * Whether an existing index already serves equality lookups on `column`.
+     *
+     * Single-column shorthand for {@link hasUnqualifiedLeadingColumns}.
+     */
+    private hasUnqualifiedLeadingIndex;
+    /**
+     * The column list of the default list-ordering index for a table.
+     *
+     * Every generated list surface — REST, MCP, and the SvelteKit list route —
+     * pages with `ORDER BY created_at DESC, <pk> ASC` (`DEFAULT_LIST_ORDER_BY`,
+     * #2367). On a tenant-scoped table that page is always preceded by a
+     * `tenant_id = ?` equality filter from the tenancy interceptor, so the
+     * serving index leads with the tenant column and orders inside it.
+     *
+     * `created_at` is generator-owned on every path — a declared `createdAt`
+     * field is rewritten to the same `TIMESTAMP NOT NULL DEFAULT
+     * current_timestamp` column — so it is never a primary key and never
+     * inline-UNIQUE. That is why only `indexes` needs checking for existing
+     * coverage: no constraint-backed index can already order this column.
+     *
+     * Returns `null` when the table has no `created_at` column (no path emits
+     * such a table today, but the helper stays total).
+     */
+    private getDefaultListOrderingColumns;
+    /**
+     * Ensure the table can serve its own default list page from an index.
+     *
+     * Generated REST/MCP/SvelteKit list routes all page with
+     * `ORDER BY created_at DESC, <pk> ASC LIMIT n` and no `created_at` index
+     * existed on any schema path (the dead AST path indexed `updated_at`
+     * instead), so every default list page was a sequential scan plus a top-N
+     * sort of the whole table — 21 ms against 0.1 ms with the right composite on
+     * the workload the assessment measured (#2363, finding A2).
+     *
+     * Emitted shape:
+     *
+     * - tenant-scoped table → `(<tenant column>, created_at)`. The tenancy
+     *   interceptor adds `tenant_id = ?` to every list, so the tenant column
+     *   leads and `created_at` orders within it.
+     * - otherwise → `(created_at)`.
+     *
+     * No `DESC` declaration: PostgreSQL scans a B-tree backwards just as
+     * cheaply, and `IndexDefinition` carries no per-column direction. The
+     * trailing primary-key tiebreak is left out deliberately — its direction is
+     * opposite to `created_at`'s, so no single-direction index can satisfy the
+     * whole key anyway; the leading columns turn a full sort into an index scan
+     * with an incremental sort over rows that share a timestamp.
+     *
+     * Call this AFTER {@link appendDeclaredIndexes} and BEFORE
+     * {@link ensureReferenceColumnIndexes}: a declared composite that already
+     * leads with the same columns suppresses this one, and this composite in
+     * turn suppresses the standalone tenant index that would otherwise be a
+     * redundant prefix of it.
+     */
+    private ensureDefaultListOrderingIndex;
+    /**
+     * The `(meta_type, meta_id)` owner-lookup columns for a polymorphic
+     * association table, or `null` when the table isn't one.
+     *
+     * `SmrtPolymorphicAssociation` contributes `metaType`/`metaId`/`role` (and
+     * `sortOrder`) to any concrete subclass's manifest — the scanner's
+     * `FRAMEWORK_ABSTRACT_BASE_NAMES` wiring merges the abstract base's fields
+     * directly into the subclass, because the base carries no `@smrt()`
+     * decorator of its own to declare an index on. Detected structurally, by
+     * the same three-column test `cascade.ts`'s `isPolymorphicAssociationClass`
+     * uses on registry field maps: requiring all three keeps an unrelated class
+     * that merely happens to carry a `metaType` column from being treated as an
+     * association table.
+     */
+    private getPolymorphicAssociationOwnerColumns;
+    /**
+     * Ensure a polymorphic association table indexes its owner lookup
+     * `(meta_type, meta_id)` (#2364, epic #2382 finding A3).
+     *
+     * A concrete association's `conflictColumns` lead with its own FK (e.g.
+     * `AssetAssociation`'s `asset_id, meta_type, meta_id, role`), so
+     * `meta_type`/`meta_id` sit in the *middle* of that unique index — a
+     * lookup like `AssetAssociationCollection.byLeft(metaType, metaId)`
+     * ("what points at this target") filters columns 2-3 of a 4-column index
+     * and cannot use it as a leading prefix. `metaId` is deliberately a bare
+     * string, never a typed `@foreignKey`/`@crossPackageRef` (there is no
+     * single target table), so {@link ensureReferenceColumnIndexes} never
+     * covers it either.
+     *
+     * Call this alongside {@link ensureDefaultListOrderingIndex}, before
+     * {@link ensureReferenceColumnIndexes}.
+     *
+     * Blast radius: this applies retroactively to every
+     * `SmrtPolymorphicAssociation` subclass across every package on the next
+     * `db:migrate`, not only the ones a given change touches — roll the wave
+     * out with `smrt db:migrate --postgres-safe` (#2362), same as any other
+     * bulk index addition.
+     */
+    private ensurePolymorphicAssociationIndex;
+    /**
+     * Append `@smrt({ indexes: [...] })` declarations to a generated index set
+     * (#2357).
+     *
+     * Shared by every schema path — build-time AST, runtime registry CTI/STI, and
+     * manifest CTI/STI — so one declaration behaves identically however the schema
+     * was derived. Call it *first*, ahead of
+     * {@link ensureDefaultListOrderingIndex} (#2363) and
+     * {@link ensureReferenceColumnIndexes}: a declared composite leading with a
+     * reference column (e.g. `tenant_id`), or with the default ordering columns,
+     * is exactly what those helpers' leads-with check is meant to defer to, and
+     * appending afterwards would leave the table with a redundant standalone
+     * index (#2384, #2359).
+     *
+     * Nothing is dropped quietly. A column that resolves to no column on the
+     * table, a malformed entry, and a name collision with a different index are
+     * all hard errors — a silently missing index is a production performance bug
+     * that surfaces only under load.
+     *
+     * @param indexes - Generated index set, appended in place
+     * @param declared - The object's `indexes` config, from any config source
+     * @param columns - Emitted columns, keyed by column name
+     * @param tableName - Table the indexes belong to (for error messages)
+     */
+    private appendDeclaredIndexes;
+    /** Narrow one raw `indexes[]` entry, rejecting anything unusable. */
+    private validateDeclaredIndex;
+    /**
+     * Resolve a declared index column to an emitted column name.
+     *
+     * Declarations name SMRT fields, but only the runtime/manifest paths
+     * snake_case them into columns — the build-time AST path keys columns by the
+     * field name itself. Prefer an exact column hit, then the snake_case form, and
+     * otherwise return the input unchanged so the caller reports it as unknown.
+     */
+    private resolveDeclaredIndexColumn;
+    /** Whether two index definitions describe the same database object. */
+    private sameIndexTarget;
+    /**
+     * Ensure every reference column — `@foreignKey`, `@crossPackageRef`, and the
+     * tenancy-injected `tenant_id` — has an index leading with it.
+     *
+     * These are the columns every relationship load, `include:` batch, reverse
+     * ownership lookup and tenant-scoped read filters on. Before #2359 only the
+     * registry (test) paths indexed foreign keys, the manifest (production)
+     * paths indexed none of them, and `tenant_id` was indexed nowhere (#2356):
+     * 196/231 `@foreignKey` and 91/92 `@crossPackageRef` columns shipped with no
+     * serving index. Every schema path now calls this helper so the four paths
+     * stay in step (see `schema-path-parity.test.ts`).
+     *
+     * "Leading with it" rather than "always add": a table that already has an
+     * unqualified index starting on the column (commonly the `conflictColumns`
+     * unique index, or an `indexed: true` opt-in) is already served, and a
+     * standalone duplicate would only cost writes. A *partial* index does not
+     * count — see {@link hasUnqualifiedLeadingIndex}.
+     *
+     * Reference columns are therefore always indexed; `indexed: true` on one of
+     * them is redundant and harmless.
+     *
+     * Call this LAST in every path, after every other index (conflict, opt-in,
+     * unique, the declared composites, the default list-ordering composite, and
+     * any future addition) has been appended, so the leads-with suppression sees
+     * the full set. In particular {@link ensureDefaultListOrderingIndex} runs
+     * first on a tenant-scoped table: its `(tenant_id, created_at)` composite
+     * serves the tenant equality filter too, so no standalone tenant index is
+     * added (#2363).
+     */
+    private ensureReferenceColumnIndexes;
+    /**
+     * Whether `conflictColumns` names exactly the primary key column(s).
+     *
+     * `ON CONFLICT (id)` binds to the primary-key constraint on every engine, so
+     * a separate unique index over the same column set is a second B-tree over
+     * the same random UUIDs with nothing to add (#2359, finding A5).
+     */
+    private conflictColumnsArePrimaryKey;
+    /**
+     * The table's tenant column as the generated columns describe it: the
+     * column carrying `referenceKind: 'tenantId'` (set from the field's
+     * `__tenancy.isTenantIdField` marker on every path).
+     */
+    private findTenantColumn;
+    /**
+     * Resolve the conflict target the unique conflict index must cover
+     * (#2360). `config.conflictColumns` wins when the caller resolved it —
+     * registry callers pass `ObjectRegistry.getConflictColumns()`, the manifest
+     * pipeline passes the normalized `decoratorConfig` — otherwise the strategy
+     * default, led by the tenant column when `config.tenantScoped` names a
+     * tenant field that exists as a column. Both roads apply the same rule as
+     * `ObjectRegistry.getConflictColumns()`, so schema and upsert agree by
+     * construction (`schema-path-parity.test.ts`).
+     */
+    private resolveConflictTarget;
+    /**
+     * Keep `(slug, context)` lookups served when `conflictColumns` are custom.
+     *
+     * The default conflict index is `(slug, context)`, and `loadFromSlug()`,
+     * `getId()` and `getSavedId()` all filter on `slug`/`context` regardless of
+     * the configured conflict key. A class that declares custom conflict
+     * columns replaces that unique index and, before #2359, left those lookups
+     * with no index at all — 120 tables (finding A7).
+     *
+     * Emitting a plain `(slug, context)` index is the safer of the two fixes:
+     * routing the lookups through the conflict key would change which row a
+     * slug resolves to on every such class, whereas an extra non-unique index
+     * is purely additive. It is skipped when an unqualified index already
+     * serves the lookup — one leading with `slug` (e.g. custom conflict columns
+     * that still start with it), or the tenant-led default key
+     * `(tenant_id, slug, context)` of a tenant-scoped table (#2360): every slug
+     * lookup on such a table carries the tenant predicate (#2365) and is served
+     * by that prefix, so a second index would only cost writes.
+     */
+    private ensureSlugLookupIndex;
+    /**
+     * Emit the unique conflict index of an STI table from the resolved
+     * conflict target (#2360): the STI default `(slug, context, _meta_type)`,
+     * a custom `@smrt({ conflictColumns })` declared on the STI root, or the
+     * default led by the tenant column when the root is tenant-scoped. Shared
+     * by the registry and manifest STI paths so they cannot drift.
+     *
+     * No index is emitted when the target is the primary key itself
+     * (`ON CONFLICT (id)` binds to the PK constraint), matching the CTI paths.
+     */
+    private emitStiConflictIndex;
+    /**
+     * Emit unique indexes for `@field({ unique: true })` columns on an STI table.
+     *
+     * STI columns are the union of every class in the hierarchy, all nullable,
+     * so a column-level `UNIQUE` (what CTI renders inline) is not enough on its
+     * own: the migration differ cannot add a column constraint to an existing
+     * table, but it can add an index. Two shapes (#2359, finding A4):
+     *
+     * - declared on the STI **base** (and therefore inherited by every class in
+     *   the table): one full unique index, table-wide like CTI;
+     * - declared only on a **descendant**: one partial unique index per class
+     *   that carries the flag (the declaring class and, through inherited field
+     *   metadata, its own descendants), `WHERE _meta_type = '<qualified>'`, so
+     *   siblings that merely share the column name are not constrained.
+     *   Uniqueness is then enforced per concrete class, not across the subtree
+     *   — a documented limitation of the discriminator-partial shape. Engines
+     *   without partial indexes (DuckDB, JSON) skip this shape entirely rather
+     *   than widen it to a table-wide UNIQUE (see DuckDBStrategy.generateIndexes
+     *   and SchemaComparer.compareIndexes).
+     *
+     * @param declarers - column name → classes whose field metadata carries
+     *   `unique: true` for that column, in hierarchy order (base first).
+     */
+    private emitStiUniqueIndexes;
     /**
      * Generate index definitions
      */
@@ -106,7 +387,14 @@ export declare class SchemaGenerator {
      * - _meta_type: Discriminator column to identify class type
      * - _meta_data: JSON column for flexible field storage
      * - Union of all FK columns from descendants (all nullable)
-     * - Partial indexes for FK columns (filtered by _meta_type)
+     * - One plain index per reference column (FK / cross-package ref /
+     *   tenant_id). Plain rather than partial-by-class: base-class polymorphic
+     *   queries carry no `_meta_type` predicate, so a partial index could not
+     *   serve them, while a plain index serves both those and the child
+     *   collections' `_meta_type = X AND fk = ?` filters — one index per column
+     *   instead of one per (column, class) (#2359).
+     * - Unique indexes for `@field({ unique: true })` columns — see
+     *   {@link emitStiUniqueIndexes}.
      *
      * @param baseClassName - Base class name for the STI hierarchy
      * @param tableName - Shared table name (from base class)
@@ -155,6 +443,13 @@ export declare class SchemaGenerator {
      * @returns ManifestSchema for storage in manifest.json
      */
     generateCTISchemaFromManifest(className: string, tableName: string, fields: Record<string, FieldDefinition>, config?: SchemaGeneratorConfig): ManifestSchema;
+    /**
+     * Resolve a class name (simple or qualified) to the key it is stored under
+     * in `manifest.objects`. Falls back to the input when the manifest does not
+     * carry the class (e.g. an external STI base absent from the aggregated
+     * manifest), so callers can keep using it as an opaque label.
+     */
+    private resolveManifestClassKey;
     /**
      * Find all descendants of a class in the manifest
      *
@@ -174,13 +469,19 @@ export declare class SchemaGenerator {
      */
     private toSnakeCase;
     /**
-     * Generate SQL CREATE TABLE statement from schema definition
+     * Generate the CREATE TABLE statement for a schema definition.
      *
-     * This is the single source of truth for SQL generation, consolidating
-     * logic that was previously duplicated across multiple code paths.
+     * With an `engine` this delegates to that engine's DDL strategy. Without
+     * one it renders the engine-neutral preview stored in `schema.ddl` and
+     * `manifest.json`: abstract SQL types, no indexes, no triggers. That
+     * preview is NOT an executable representation of the table (#2358) —
+     * executable paths (`db:migrate`, `MigrationGenerator`, `SchemaAggregator`,
+     * `createIsolatedTestDbFromManifest`) render `schema.columns` and
+     * `schema.indexes` through `getDDLStrategy(engine)` instead.
      *
      * @param schema - Schema definition object
-     * @returns SQL CREATE TABLE statement with indexes
+     * @param engine - Optional target engine; omit for the neutral preview
+     * @returns SQL CREATE TABLE statement (no indexes)
      */
     generateSQL(schema: SchemaDefinition, engine?: DatabaseEngine): string;
     /**

package/dist/schema/generator.d.ts.map

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