@happyvertical/smrt-core 0.36.8 → 0.37.1

package/dist/manifest.json

@@ -1,8 +1,8 @@
 {
   "version": "1.0.0",
-  "timestamp": 1782522843119,
+  "timestamp": 1782792357137,
   "packageName": "@happyvertical/smrt-core",
-  "packageVersion": "0.36.8",
+  "packageVersion": "0.37.1",
   "objects": {
     "@happyvertical/smrt-core:SmrtClass": {
       "name": "smrtclass",
@@ -235,7 +235,7 @@
           "parameters": [
             {
               "name": "filter",
-              "type": "string | Record<string, any>",
+              "type": "string | SmrtWhereClause<ModelType>",
               "optional": false
             },
             {
@@ -268,12 +268,12 @@
           "parameters": [
             {
               "name": "data",
-              "type": "any",
+              "type": "Record<string>",
               "optional": false
             },
             {
               "name": "defaults",
-              "type": "any",
+              "type": "Record<string>",
               "optional": true
             }
           ],
@@ -287,16 +287,16 @@
           "parameters": [
             {
               "name": "existing",
-              "type": "Record<string, any>",
+              "type": "SmrtObject | Record<string>",
               "optional": false
             },
             {
               "name": "data",
-              "type": "Record<string, any>",
+              "type": "Record<string>",
               "optional": false
             }
           ],
-          "returnType": "Promise<Record<string, any> | null>",
+          "returnType": "Promise<Record<string> | null>",
           "isStatic": false,
           "isPublic": true
         },
@@ -304,7 +304,7 @@
           "name": "getFields",
           "async": true,
           "parameters": [],
-          "returnType": "any",
+          "returnType": "Promise<Record<string, CollectionFieldDefinition>>",
           "isStatic": false,
           "isPublic": true
         },
@@ -312,7 +312,7 @@
           "name": "getFieldsSync",
           "async": false,
           "parameters": [],
-          "returnType": "Record<string, any>",
+          "returnType": "Record<string, CollectionFieldDefinition>",
           "isStatic": false,
           "isPublic": true
         },
@@ -379,7 +379,7 @@
             },
             {
               "name": "params",
-              "type": "any[]",
+              "type": "any",
               "optional": true
             },
             {
@@ -416,7 +416,7 @@
               "optional": false
             }
           ],
-          "returnType": "Promise<any | null>",
+          "returnType": "Promise",
           "isStatic": false,
           "isPublic": true
         },
@@ -430,7 +430,7 @@
               "optional": true
             }
           ],
-          "returnType": "Promise<Map<string, any>>",
+          "returnType": "Promise<Map<string>>",
           "isStatic": false,
           "isPublic": true
         },
@@ -827,7 +827,7 @@
           "parameters": [
             {
               "name": "data",
-              "type": "any",
+              "type": "Record<string>",
               "optional": false
             }
           ],
@@ -839,7 +839,7 @@
           "name": "getFields",
           "async": true,
           "parameters": [],
-          "returnType": "any",
+          "returnType": "Promise<any>",
           "isStatic": false,
           "isPublic": true
         },
@@ -948,7 +948,7 @@
             },
             {
               "name": "options",
-              "type": "any",
+              "type": "AiOperationOptions",
               "optional": true
             }
           ],
@@ -967,7 +967,7 @@
             },
             {
               "name": "options",
-              "type": "any",
+              "type": "AiOperationOptions",
               "optional": true
             }
           ],
@@ -981,7 +981,7 @@
           "parameters": [
             {
               "name": "options",
-              "type": "any",
+              "type": "AiOperationOptions",
               "optional": true
             }
           ],
@@ -1011,6 +1011,25 @@
           "isStatic": false,
           "isPublic": true
         },
+        "_setLoadedRelationship": {
+          "name": "_setLoadedRelationship",
+          "async": false,
+          "parameters": [
+            {
+              "name": "fieldName",
+              "type": "string",
+              "optional": false
+            },
+            {
+              "name": "value",
+              "type": "any",
+              "optional": false
+            }
+          ],
+          "returnType": "void",
+          "isStatic": false,
+          "isPublic": true
+        },
         "loadRelated": {
           "name": "loadRelated",
           "async": true,
@@ -1114,7 +1133,7 @@
               "optional": false
             }
           ],
-          "returnType": "Promise<any | null>",
+          "returnType": "Promise",
           "isStatic": false,
           "isPublic": true
         },
@@ -1128,7 +1147,7 @@
               "optional": true
             }
           ],
-          "returnType": "Promise<Map<string, any>>",
+          "returnType": "Promise<Map<string>>",
           "isStatic": false,
           "isPublic": true
         },

package/dist/migrations/differ.d.ts

@@ -29,6 +29,35 @@ export interface DiffOptions {
      */
     engineHint?: string;
 }
+/**
+ * Normalize a partial-index `WHERE` predicate so semantically-identical
+ * clauses from different sources compare equal (issue #1692).
+ *
+ * The manifest stores predicates roughly as written (`_meta_type = 'Article'`),
+ * SQLite/DuckDB echo the original CREATE INDEX text verbatim, and PostgreSQL
+ * re-renders them with type casts and extra parentheses
+ * (`((_meta_type)::text = 'Article'::text)`). Normalization:
+ *
+ * - strips a leading `WHERE` keyword,
+ * - removes PostgreSQL `::type` casts (single-word type names — the only kind
+ *   SMRT-generated partial predicates produce, e.g. `_meta_type::text`),
+ * - removes parentheses (SMRT only emits simple `col = 'literal'` predicates,
+ *   so grouping carries no meaning here),
+ * - lowercases everything OUTSIDE single-quoted string literals (SQL keywords
+ *   and identifiers are case-insensitive; literals such as STI discriminator
+ *   class names are case-sensitive, so they are preserved verbatim),
+ * - collapses whitespace and tightens spacing around comparison operators.
+ *
+ * Returns '' for an absent/empty predicate (i.e. a non-partial index).
+ */
+export declare function normalizeIndexPredicate(where?: string | null): string;
+/**
+ * Extract the normalized partial-index predicate from a `CREATE INDEX`
+ * statement — the `WHERE` tail that follows the column-list close paren.
+ * Works for both SQLite/DuckDB `sqlite_master.sql` text and PostgreSQL
+ * `pg_indexes.indexdef`. Returns '' for a non-partial index.
+ */
+export declare function extractIndexPredicate(createIndexSql: string): string;
 /**
  * SchemaComparer class for comparing manifest schemas to database
  */
@@ -55,7 +84,7 @@ export declare class SchemaComparer {
     /**
      * Compare indexes between manifest and database
      *
-     * Three classes of drift the differ now detects:
+     * Four classes of drift the differ now detects:
      *
      * 1. **Missing index** — manifest has an index neither the DB has by name
      *    nor any equivalent-by-signature. Emit `add_index`. (Issue #741: the
@@ -63,11 +92,13 @@ export declare class SchemaComparer {
      *    classes register indexes with different name prefixes.)
      *
      * 2. **Same-name shape drift** — DB has an index with the manifest's name,
-     *    but its columns or uniqueness flag differ. This is the failure mode
-     *    in issue #1165: `tenants_slug_context_meta_type_idx` exists but is
-     *    non-unique, while the manifest declares it unique. Emit
-     *    `drop_index` + `add_index` so the next migrate cycle recreates it
-     *    with the correct shape.
+     *    but its columns, uniqueness flag, or partial-index `WHERE` predicate
+     *    differ. This covers the uniqueness flip in issue #1165
+     *    (`tenants_slug_context_meta_type_idx` materialized non-unique while
+     *    the manifest declares it unique) and the predicate drift in issue
+     *    #1692 (a partial index whose `WHERE` clause was added, removed, or
+     *    altered). Emit `drop_index` + `add_index` so the next migrate cycle
+     *    recreates it with the correct shape.
      *
      * 3. **Orphan in DB** — DB has an index with no manifest counterpart by
      *    name and no signature equivalent. Emit `drop_index` *only* when the
@@ -75,20 +106,36 @@ export declare class SchemaComparer {
      *    PostgreSQL implicit indexes (`*_pkey`, `*_key`) — those are owned by
      *    table-level constraints and need a separate `DROP CONSTRAINT` path
      *    that the differ does not emit yet.
+     *
+     * 4. **Partial-index predicate drift / collision** — two indexes on the
+     *    same column(s) and uniqueness that differ only by their `WHERE`
+     *    predicate (e.g. distinct STI child partial indexes) are no longer
+     *    collapsed to one signature, so the signature-equivalence path (b)
+     *    won't claim one for the other.
+     *
+     * @param dbIndexPredicates - Normalized `WHERE` predicate per DB index
+     *   name from {@link getDbIndexPredicates}. `null` means predicate
+     *   introspection was unavailable for this engine/adapter, in which case
+     *   the comparison falls back to predicate-unaware signatures (the prior
+     *   behavior) so existing partial indexes are never flagged as false drift.
      */
     private compareIndexes;
     /**
-     * Generate a signature for an index based on its columns and uniqueness.
-     * Used for functional equivalence checking (Issue #741).
+     * Generate a signature for an index based on its columns, uniqueness, and
+     * (normalized) partial-index predicate. Used for functional equivalence
+     * checking (Issue #741) and predicate-drift detection (Issue #1692).
      *
      * Note: Column order is preserved because it is semantically significant for
      * composite indexes. An index on (a, b) is NOT equivalent to (b, a) - they
      * have different query performance characteristics.
      *
-     * Limitation: Partial indexes (with WHERE clauses) are not fully supported.
-     * The database introspection layer doesn't provide WHERE clause information,
-     * so two partial indexes with the same columns but different WHERE clauses
-     * cannot be distinguished and may be incorrectly treated as equivalent.
+     * The trailing predicate component distinguishes partial indexes that share
+     * columns and uniqueness but differ by their `WHERE` clause (e.g. distinct
+     * STI child partial indexes). Callers pass the already-normalized predicate
+     * so both the manifest (desired) and introspected (DB) sides compare equal
+     * for semantically-identical clauses. An empty string means "no predicate"
+     * (a non-partial index) and is also used on both sides when predicate
+     * introspection is unavailable, preserving the prior behavior.
      *
      * For JSON-path indexes (`@meta({ indexed: true })`) the signature is
      * derived from the JSON path instead of an empty column list, so the
@@ -96,9 +143,44 @@ export declare class SchemaComparer {
      *
      * @param idxOrColumns - Either an IndexDefinition or a column array (legacy)
      * @param uniqueArg - Unique flag (used when first arg is a column array)
+     * @param predicateArg - Normalized partial-index predicate (default '')
      * @returns Signature string
      */
     private getIndexSignature;
+    /**
+     * Whether the active engine supports partial indexes (`CREATE INDEX … WHERE`).
+     *
+     * SQLite and PostgreSQL do. DuckDB rejects them outright, and the JSON
+     * adapter is DuckDB-backed, so on those engines a "partial" index can only
+     * ever exist as a full index. Treating the predicate as significant there
+     * would (a) flag existing full indexes as false drift and (b) emit
+     * `CREATE INDEX … WHERE` DDL the engine rejects, breaking the migration.
+     * Gating on this keeps both the comparison and the generated DDL aligned
+     * with what the engine actually accepts (a partial index degrades to a
+     * full index), matching the pre-#1692 behavior on those engines.
+     */
+    private supportsPartialIndexes;
+    /**
+     * Introspect partial-index predicates for a table, keyed by index name.
+     *
+     * `getTableSchema()` (the @happyvertical/sql introspection) returns only
+     * name/columns/unique, so the `WHERE` predicate is read directly here:
+     *
+     * - PostgreSQL: `pg_indexes.indexdef` carries the full CREATE INDEX text.
+     * - SQLite: the `sqlite_master.sql` column carries the original CREATE INDEX
+     *   text.
+     *
+     * Engines that don't support partial indexes (DuckDB / the DuckDB-backed
+     * JSON adapter) short-circuit to `null` so the comparison stays
+     * predicate-unaware there — see {@link supportsPartialIndexes}.
+     *
+     * Non-partial indexes are omitted from the map (callers treat a missing
+     * entry as the empty predicate). Returns `null` when the catalog query
+     * fails — e.g. an adapter exposing neither catalog — so the index
+     * comparison can fall back to predicate-unaware behavior rather than
+     * flagging every existing partial index as false drift.
+     */
+    private getDbIndexPredicates;
     /**
      * Get list of existing tables from database
      */
@@ -152,7 +234,16 @@ export declare class SchemaComparer {
      */
     private generateDropColumnSQL;
     /**
-     * Generate SQL for adding an index
+     * Generate SQL for adding an index.
+     *
+     * On engines that support partial indexes (SQLite/PostgreSQL) this mirrors
+     * the canonical CREATE INDEX path in the DDL strategies: a partial index
+     * appends its `WHERE` predicate so a detected predicate add/alter (issue
+     * #1692) recreates the index with the correct partial condition rather than
+     * silently widening it to a full index. On DuckDB / the JSON adapter — which
+     * reject partial indexes — the predicate is dropped so the emitted DDL stays
+     * executable (a partial index degrades to a full index there). The predicate
+     * is trimmed and a redundant leading `WHERE` stripped for robustness.
      */
     private generateAddIndexSQL;
     /**

package/dist/migrations/differ.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"differ.d.ts","sourceRoot":"","sources":["../../src/migrations/differ.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAKH,OAAO,KAAK,EAGV,YAAY,EACZ,gBAAgB,EAChB,UAAU,EAEX,MAAM,oBAAoB,CAAC;AAE5B,OAAO,KAAK,EAAE,iBAAiB,EAAsB,MAAM,YAAY,CAAC;AA8BxE;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,iEAAiE;IACjE,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,kEAAkE;IAClE,qBAAqB,CAAC,EAAE,OAAO,CAAC;IAChC;;;;;;;OAOG;IACH,qBAAqB,CAAC,EAAE,OAAO,CAAC;IAChC,iDAAiD;IACjD,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B;;;;;;;OAOG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAuBD;;GAEG;AACH,qBAAa,cAAc;IACzB,OAAO,CAAC,EAAE,CAAoB;IAC9B,OAAO,CAAC,OAAO,CAAc;IAC7B,OAAO,CAAC,MAAM,CAAiB;IAC/B,OAAO,CAAC,WAAW,CAAoC;gBAE3C,EAAE,EAAE,iBAAiB,EAAE,OAAO,GAAE,WAAgB;IAsB5D;;OAEG;IACG,OAAO,CACX,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,GAChD,OAAO,CAAC,UAAU,CAAC;IA4CtB;;OAEG;IACG,YAAY,CAChB,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,gBAAgB,GACzB,OAAO,CAAC,YAAY,EAAE,CAAC;IAqB1B;;OAEG;IACH,OAAO,CAAC,cAAc;IAwItB,OAAO,CAAC,0BAA0B;IAkBlC,OAAO,CAAC,gCAAgC;IAexC;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,OAAO,CAAC,cAAc;IAoJtB;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,OAAO,CAAC,iBAAiB;IAczB;;OAEG;YACW,iBAAiB;IAgB/B;;OAEG;IACH,OAAO,CAAC,aAAa;IAmDrB;;;;;;;;;;;;;;OAcG;IACH,OAAO,CAAC,uBAAuB;IAiD/B;;;;;;;OAOG;IACH,OAAO,CAAC,sBAAsB;IAoI9B;;OAEG;IACH,OAAO,CAAC,eAAe;IAIvB;;;;OAIG;IACH,OAAO,CAAC,mCAAmC;IAgB3C,OAAO,CAAC,YAAY;IAIpB;;OAEG;IACH,OAAO,CAAC,oBAAoB;IAiD5B;;OAEG;IACH,OAAO,CAAC,qBAAqB;IAI7B;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAM3B;;;;;;;;;;;;;OAaG;IACH,OAAO,CAAC,oBAAoB;CAG7B;AAED;;GAEG;AACH,wBAAsB,kBAAkB,CACtC,EAAE,EAAE,iBAAiB,EACrB,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,EACjD,OAAO,GAAE,WAAgB,GACxB,OAAO,CAAC,UAAU,CAAC,CAGrB;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAI9D;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,UAAU,GAAG,MAAM,EAAE,CAgBzD"}
+{"version":3,"file":"differ.d.ts","sourceRoot":"","sources":["../../src/migrations/differ.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAKH,OAAO,KAAK,EAGV,YAAY,EACZ,gBAAgB,EAChB,UAAU,EAEX,MAAM,oBAAoB,CAAC;AAE5B,OAAO,KAAK,EAAE,iBAAiB,EAAsB,MAAM,YAAY,CAAC;AA8BxE;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,iEAAiE;IACjE,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,kEAAkE;IAClE,qBAAqB,CAAC,EAAE,OAAO,CAAC;IAChC;;;;;;;OAOG;IACH,qBAAqB,CAAC,EAAE,OAAO,CAAC;IAChC,iDAAiD;IACjD,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B;;;;;;;OAOG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAuBD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,uBAAuB,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,MAAM,CAsCrE;AAiBD;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,cAAc,EAAE,MAAM,GAAG,MAAM,CAOpE;AAED;;GAEG;AACH,qBAAa,cAAc;IACzB,OAAO,CAAC,EAAE,CAAoB;IAC9B,OAAO,CAAC,OAAO,CAAc;IAC7B,OAAO,CAAC,MAAM,CAAiB;IAC/B,OAAO,CAAC,WAAW,CAAoC;gBAE3C,EAAE,EAAE,iBAAiB,EAAE,OAAO,GAAE,WAAgB;IAsB5D;;OAEG;IACG,OAAO,CACX,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,GAChD,OAAO,CAAC,UAAU,CAAC;IA4CtB;;OAEG;IACG,YAAY,CAChB,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,gBAAgB,GACzB,OAAO,CAAC,YAAY,EAAE,CAAC;IAkC1B;;OAEG;IACH,OAAO,CAAC,cAAc;IAwItB,OAAO,CAAC,0BAA0B;IAkBlC,OAAO,CAAC,gCAAgC;IAexC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAqCG;IACH,OAAO,CAAC,cAAc;IA2KtB;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,OAAO,CAAC,iBAAiB;IAezB;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,sBAAsB;IAI9B;;;;;;;;;;;;;;;;;;;OAmBG;YACW,oBAAoB;IAmDlC;;OAEG;YACW,iBAAiB;IAoB/B;;OAEG;IACH,OAAO,CAAC,aAAa;IAmDrB;;;;;;;;;;;;;;OAcG;IACH,OAAO,CAAC,uBAAuB;IAiD/B;;;;;;;OAOG;IACH,OAAO,CAAC,sBAAsB;IAoI9B;;OAEG;IACH,OAAO,CAAC,eAAe;IAIvB;;;;OAIG;IACH,OAAO,CAAC,mCAAmC;IAgB3C,OAAO,CAAC,YAAY;IAIpB;;OAEG;IACH,OAAO,CAAC,oBAAoB;IAiD5B;;OAEG;IACH,OAAO,CAAC,qBAAqB;IAI7B;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,mBAAmB;IAW3B;;;;;;;;;;;;;OAaG;IACH,OAAO,CAAC,oBAAoB;CAG7B;AAED;;GAEG;AACH,wBAAsB,kBAAkB,CACtC,EAAE,EAAE,iBAAiB,EACrB,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,EACjD,OAAO,GAAE,WAAgB,GACxB,OAAO,CAAC,UAAU,CAAC,CAGrB;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAI9D;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,UAAU,GAAG,MAAM,EAAE,CAgBzD"}