firstly 0.10.3 → 0.10.4

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # firstly
 
+## 0.10.4
+
+### Patch Changes
+
+- [#375](https://github.com/jycouet/firstly/pull/375) [`b0aea3e`](https://github.com/jycouet/firstly/commit/b0aea3eef9d31339a7446e855f0dbc0c8690177f) Thanks [@jycouet](https://github.com/jycouet)! - sqlAdmin drift: `relationIndexes` skips relations keyed on a computed field (`sqlExpression` / `serverExpression`), which have no column to index and produced invalid SQL.
+
 ## 0.10.3
 
 ### Patch Changes

package/esm/sqlAdmin/server/drift/relationIndexes.d.ts

@@ -25,6 +25,8 @@ export type RelIndexPlan = {
  * (e.g. an `a` index on an `(a, b)` PK table).
  */
 export declare function planRelationIndexes(desired: RelIndexDesired[], existing: Map<string, ExistingIndex[]>): RelIndexPlan[];
+/** FK columns of each entity's `toOne` relations - the indexes we'd like to exist. */
+export declare function relationIndexTargets(entities: ClassType<unknown>[]): Promise<RelIndexDesired[]>;
 /**
  * Find - and optionally create - indexes for `toOne` relation FK columns that
  * aren't already covered by an existing index. Default is a dry run: returns the

package/esm/sqlAdmin/server/drift/relationIndexes.js

@@ -33,18 +33,8 @@ export function planRelationIndexes(desired, existing) {
     }
     return plans;
 }
-/**
- * Find - and optionally create - indexes for `toOne` relation FK columns that
- * aren't already covered by an existing index. Default is a dry run: returns the
- * plan, changes nothing. Pass `{ apply: true }` to create the missing ones.
- *
- * Postgres does NOT auto-index FK columns, and `toMany` relations are indexed
- * from their owning `toOne` side, so only `toOne` is considered. Creates use
- * `CREATE INDEX IF NOT EXISTS` (idempotent), so they join the BackendMethod's
- * transaction - which is also why they can't be `CONCURRENTLY`.
- */
-export async function createRelationIndexes(db, entities, opts) {
-    // Desired FK indexes from each entity's toOne relations.
+/** FK columns of each entity's `toOne` relations - the indexes we'd like to exist. */
+export async function relationIndexTargets(entities) {
     const desired = [];
     for (const ent of entities) {
         const meta = repo(ent).metadata;
@@ -59,9 +49,30 @@ export async function createRelationIndexes(db, entities, opts) {
             const localKeys = Object.values(fi.getFields().fields); // FK columns on THIS entity
             if (localKeys.length === 0)
                 continue;
+            // A computed key (sqlExpression / serverExpression) has no column to index.
+            const computed = localKeys.some((k) => {
+                const o = meta.fields.find(k)?.options;
+                return !!(o?.sqlExpression || o?.serverExpression);
+            });
+            if (computed)
+                continue;
             desired.push({ table, columns: localKeys.map((k) => stripIdent(names.$dbNameOf(k))) });
         }
     }
+    return desired;
+}
+/**
+ * Find - and optionally create - indexes for `toOne` relation FK columns that
+ * aren't already covered by an existing index. Default is a dry run: returns the
+ * plan, changes nothing. Pass `{ apply: true }` to create the missing ones.
+ *
+ * Postgres does NOT auto-index FK columns, and `toMany` relations are indexed
+ * from their owning `toOne` side, so only `toOne` is considered. Creates use
+ * `CREATE INDEX IF NOT EXISTS` (idempotent), so they join the BackendMethod's
+ * transaction - which is also why they can't be `CONCURRENTLY`.
+ */
+export async function createRelationIndexes(db, entities, opts) {
+    const desired = await relationIndexTargets(entities);
     // Every existing index (incl. PK), columns in order, per table.
     const res = await db.createCommand().execute(`
 		SELECT c.relname AS table_name, i.relname AS index_name,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "firstly",
-  "version": "0.10.3",
+  "version": "0.10.4",
   "type": "module",
   "description": "Firstly, an opinionated Remult setup!",
   "bin": {