firstly 0.10.4 → 0.10.6

package/esm/sqlAdmin/SqlAdminController.js

@@ -8,6 +8,8 @@ import { BackendMethod, remult, repo, SqlDatabase } from 'remult';
 import { FF_Role } from '../core/common';
 import { Roles_SqlAdmin } from './Roles_SqlAdmin';
 import { SQL_CAPABILITIES, SQL_TOKEN_TTLS, SqlToken, SqlTokenCall, } from './sqlTokenEntities';
+// Thrown when a server-only body runs on the client (its `import.meta.env.SSR` block is gone there).
+export const SERVER_ONLY = 'sqlAdmin: server-only';
 export const SQL_ADMINS = [Roles_SqlAdmin.SqlAdmin_Admin, FF_Role.FF_Role_Admin];
 const CALL_LOG_CMD_MAX = 4000;
 /** Retention is a housekeeping sweep, not something to pay for on every query. */
@@ -42,21 +44,24 @@ export class SqlAdminController {
         return SqlAdminController.run(cmd, capabilities);
     }
     static async run(cmd, capabilities) {
-        const db = getDb();
-        try {
-            // Anything that is not an explicit list (null, a stray boolean) is a read.
-            if (Array.isArray(capabilities) && capabilities.includes('write')) {
-                const start = performance.now();
-                const rows = (await db.execute(cmd)).rows;
-                return { rows, rowCount: rows.length, took: performance.now() - start };
+        if (import.meta.env.SSR) {
+            const db = getDb();
+            try {
+                // Anything that is not an explicit list (null, a stray boolean) is a read.
+                if (Array.isArray(capabilities) && capabilities.includes('write')) {
+                    const start = performance.now();
+                    const rows = (await db.execute(cmd)).rows;
+                    return { rows, rowCount: rows.length, took: performance.now() - start };
+                }
+                const { readOnlySql } = await import('./server/readOnlySql');
+                return await readOnlySql(db, SqlAdminController.options.tokens?.pool ?? poolFrom(db), cmd);
+            }
+            catch (err) {
+                const { enrichSqlError } = await import('./server/sqlError');
+                throw await enrichSqlError(db, err, cmd);
             }
-            const { readOnlySql } = await import('./server/readOnlySql');
-            return await readOnlySql(db, SqlAdminController.options.tokens?.pool ?? poolFrom(db), cmd);
-        }
-        catch (err) {
-            const { enrichSqlError } = await import('./server/sqlError');
-            throw await enrichSqlError(db, err, cmd);
         }
+        throw new Error(SERVER_ONLY);
     }
     static async execAsToken(token, cmd) {
         const o = SqlAdminController.options.tokens;
@@ -115,18 +120,21 @@ export class SqlAdminController {
             if (!o.capabilities.includes(c))
                 throw new Error(`${c} is not enabled`);
         }
-        const { newRawToken, hashToken, tokenHint, randomTokenName } = await import('./server/token');
-        const prefix = o.prefix ?? 'ffsql_';
-        const raw = newRawToken(prefix);
-        await repo(SqlToken).insert({
-            name: name.trim() || randomTokenName(),
-            hint: tokenHint(raw, prefix),
-            tokenHash: hashToken(raw),
-            userId,
-            capabilities: unique,
-            expiresAt: new Date(Date.now() + ttlMs),
-        });
-        return raw;
+        if (import.meta.env.SSR) {
+            const { newRawToken, hashToken, tokenHint, randomTokenName } = await import('./server/token');
+            const prefix = o.prefix ?? 'ffsql_';
+            const raw = newRawToken(prefix);
+            await repo(SqlToken).insert({
+                name: name.trim() || randomTokenName(),
+                hint: tokenHint(raw, prefix),
+                tokenHash: hashToken(raw),
+                userId,
+                capabilities: unique,
+                expiresAt: new Date(Date.now() + ttlMs),
+            });
+            return raw;
+        }
+        throw new Error(SERVER_ONLY);
     }
     /**
      * Deletes every token that can no longer be used (expired or revoked), and

package/esm/sqlAdmin/SqlDriftController.js

@@ -5,7 +5,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
 import { BackendMethod, remult, SqlDatabase } from 'remult';
-import { SQL_ADMINS } from './SqlAdminController';
+import { SERVER_ONLY, SQL_ADMINS } from './SqlAdminController';
 export class SqlDriftController {
     /** Set by the `sqlAdmin()` module's `initApi`. */
     static options;
@@ -27,24 +27,36 @@ export class SqlDriftController {
     }
     // Each apply shares the BackendMethod transaction: any failure rolls every statement back.
     static async relationIndexes(opts) {
-        const { db, entities } = SqlDriftController.ctx('relationIndexes');
-        const { createRelationIndexes } = await import('./server/drift/relationIndexes');
-        return createRelationIndexes(db, entities, opts);
+        if (import.meta.env.SSR) {
+            const { db, entities } = SqlDriftController.ctx('relationIndexes');
+            const { createRelationIndexes } = await import('./server/drift/relationIndexes');
+            return createRelationIndexes(db, entities, opts);
+        }
+        throw new Error(SERVER_ONLY);
     }
     static async primaryKeys(opts) {
-        const { db, entities } = SqlDriftController.ctx('primaryKeys');
-        const { reindexPrimaryKeys } = await import('./server/drift/primaryKeys');
-        return reindexPrimaryKeys(db, entities, opts);
+        if (import.meta.env.SSR) {
+            const { db, entities } = SqlDriftController.ctx('primaryKeys');
+            const { reindexPrimaryKeys } = await import('./server/drift/primaryKeys');
+            return reindexPrimaryKeys(db, entities, opts);
+        }
+        throw new Error(SERVER_ONLY);
     }
     static async nullable(opts) {
-        const { db, entities } = SqlDriftController.ctx('nullable');
-        const { syncNullable } = await import('./server/drift/nullable');
-        return syncNullable(db, entities, opts);
+        if (import.meta.env.SSR) {
+            const { db, entities } = SqlDriftController.ctx('nullable');
+            const { syncNullable } = await import('./server/drift/nullable');
+            return syncNullable(db, entities, opts);
+        }
+        throw new Error(SERVER_ONLY);
     }
     static async orphanColumns(opts) {
-        const { db, entities } = SqlDriftController.ctx('orphanColumns');
-        const { dropColumns } = await import('./server/drift/orphanColumns');
-        return dropColumns(db, entities, opts);
+        if (import.meta.env.SSR) {
+            const { db, entities } = SqlDriftController.ctx('orphanColumns');
+            const { dropColumns } = await import('./server/drift/orphanColumns');
+            return dropColumns(db, entities, opts);
+        }
+        throw new Error(SERVER_ONLY);
     }
 }
 __decorate([

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

@@ -0,0 +1,4 @@
+import type { SqlDatabase } from 'remult';
+export declare function execStmt(db: SqlDatabase, sql: string): Promise<import("remult").SqlResult>;
+/** Live tables as `tableKey`s: an entity's table may never have been created (no migration run yet). */
+export declare function liveTables(db: SqlDatabase): Promise<Set<string>>;

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

@@ -0,0 +1,25 @@
+import { enrichSqlError } from '../sqlError';
+import { tableKeySql, USER_SCHEMA_SQL } from './ident';
+// A drift apply runs many statements in one transaction: without the statement, a
+// bare "could not create unique index" can't be traced back to its table.
+export async function execStmt(db, sql) {
+    try {
+        return await db.createCommand().execute(sql);
+    }
+    catch (err) {
+        const enriched = await enrichSqlError(db, err, sql);
+        const msg = enriched instanceof Error ? enriched.message : String(enriched);
+        throw new Error(`${msg}\n\nWhile running: ${sql.trim()}\nNothing was applied (rolled back).`, {
+            cause: err,
+        });
+    }
+}
+/** Live tables as `tableKey`s: an entity's table may never have been created (no migration run yet). */
+export async function liveTables(db) {
+    const res = await db.createCommand().execute(`
+		SELECT ${tableKeySql('table_schema', 'table_name')} AS table_key
+		FROM information_schema.tables
+		WHERE ${USER_SCHEMA_SQL('table_schema')} AND table_type = 'BASE TABLE';
+	`);
+    return new Set(res.rows.map((r) => r.table_key));
+}

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

@@ -14,6 +14,8 @@ export type IndexOptions = {
 export declare function formatCreateIndex(o: {
     name: string;
     table: string;
+    /** Omit for the search path (usually `public`). */
+    schema?: string;
     columns: string[];
     unique?: boolean;
     concurrently?: boolean;

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

@@ -14,7 +14,8 @@ export function formatCreateIndex(o) {
         parts.push('CONCURRENTLY');
     if (o.ifNotExists)
         parts.push('IF NOT EXISTS');
-    parts.push(wrap(o.name), 'ON', wrap(o.table), `(${o.columns.map(wrap).join(', ')})`);
+    const table = o.schema ? `${wrap(o.schema)}.${wrap(o.table)}` : wrap(o.table);
+    parts.push(wrap(o.name), 'ON', table, `(${o.columns.map(wrap).join(', ')})`);
     return parts.join(' ') + ';';
 }
 /**

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

@@ -1,2 +1,18 @@
 /** pg catalog / metadata names can come back quoted or schema-qualified. */
 export declare const stripIdent: (name: string) => string;
+/**
+ * Table key shared by metadata and catalog sides of every diff: bare name in `public`,
+ * `schema.name` elsewhere - so an entity in another schema is neither lost nor
+ * mistaken for a same-named `public` table.
+ */
+export declare function tableKey(dbName: string): string;
+/** Same key, computed in SQL from a schema and a table column. */
+export declare const tableKeySql: (schema: string, table: string) => string;
+export declare function splitKey(key: string): {
+    schema?: string;
+    table: string;
+};
+/** Quoted, schema-qualified SQL reference for a `tableKey`. */
+export declare function quoteTable(key: string): string;
+/** Schemas the drift checks read: every user schema, not the system ones. */
+export declare const USER_SCHEMA_SQL: (schema: string) => string;

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

@@ -1,2 +1,24 @@
 /** pg catalog / metadata names can come back quoted or schema-qualified. */
 export const stripIdent = (name) => name.replaceAll('"', '').split('.').pop();
+/**
+ * Table key shared by metadata and catalog sides of every diff: bare name in `public`,
+ * `schema.name` elsewhere - so an entity in another schema is neither lost nor
+ * mistaken for a same-named `public` table.
+ */
+export function tableKey(dbName) {
+    const [name, schema] = dbName.replaceAll('"', '').split('.').toReversed();
+    return schema && schema !== 'public' ? `${schema}.${name}` : name;
+}
+/** Same key, computed in SQL from a schema and a table column. */
+export const tableKeySql = (schema, table) => `CASE WHEN ${schema} = 'public' THEN ${table} ELSE ${schema} || '.' || ${table} END`;
+export function splitKey(key) {
+    const dot = key.indexOf('.');
+    return dot === -1 ? { table: key } : { schema: key.slice(0, dot), table: key.slice(dot + 1) };
+}
+/** Quoted, schema-qualified SQL reference for a `tableKey`. */
+export function quoteTable(key) {
+    const { schema, table } = splitKey(key);
+    return schema ? `"${schema}"."${table}"` : `"${table}"`;
+}
+/** Schemas the drift checks read: every user schema, not the system ones. */
+export const USER_SCHEMA_SQL = (schema) => `${schema} NOT IN ('pg_catalog', 'information_schema') AND ${schema} NOT LIKE 'pg\\_toast%'`;

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

@@ -1,6 +1,7 @@
 import { repo } from 'remult';
 import { getRelationFieldInfo } from 'remult/internals';
-import { stripIdent } from './ident';
+import { execStmt } from './catalog';
+import { quoteTable, stripIdent, tableKey, tableKeySql, USER_SCHEMA_SQL } from './ident';
 import { planNullableDrift, } from './planNullableDrift';
 // Only a text column has an empty value that is unambiguously "unset". A numeric or
 // boolean default (0 / false) may be genuine data, so those columns get their
@@ -31,7 +32,7 @@ export async function syncNullable(db, entities, opts) {
         const meta = repo(ent).metadata;
         if (meta.options.sqlExpression)
             continue; // views: no real table
-        const table = stripIdent(meta.dbName);
+        const table = tableKey(meta.dbName);
         for (const field of meta.fields.toArray()) {
             if (getRelationFieldInfo(field))
                 continue; // FK scalars are declared by their own field
@@ -41,13 +42,13 @@ export async function syncNullable(db, entities, opts) {
         }
     }
     const res = await db.createCommand().execute(`
-		SELECT table_name, column_name, is_nullable, column_default, data_type
+		SELECT ${tableKeySql('table_schema', 'table_name')} AS table_key, column_name, is_nullable, column_default, data_type
 		FROM information_schema.columns
-		WHERE table_schema = 'public'
-		ORDER BY table_name, ordinal_position;
+		WHERE ${USER_SCHEMA_SQL('table_schema')}
+		ORDER BY table_key, ordinal_position;
 	`);
     const current = res.rows.map((row) => ({
-        table: row.table_name,
+        table: row.table_key,
         column: row.column_name,
         isNullable: row.is_nullable === 'YES',
         hasDefault: row.column_default != null,
@@ -63,15 +64,13 @@ export async function syncNullable(db, entities, opts) {
             .map((c) => drifted.get(`${c.table}.${c.column}`))
             .filter((p) => !!p);
         for (const p of fixed) {
-            const col = `ALTER TABLE "${p.table}" ALTER COLUMN "${p.column}"`;
+            const col = `ALTER TABLE ${quoteTable(p.table)} ALTER COLUMN "${p.column}"`;
             if (p.dropDefault)
-                await db.createCommand().execute(`${col} DROP DEFAULT;`);
+                await execStmt(db, `${col} DROP DEFAULT;`);
             if (p.dropNotNull)
-                await db.createCommand().execute(`${col} DROP NOT NULL;`);
+                await execStmt(db, `${col} DROP NOT NULL;`);
             if (p.blankToNull) {
-                await db
-                    .createCommand()
-                    .execute(`UPDATE "${p.table}" SET "${p.column}" = NULL WHERE "${p.column}" = '';`);
+                await execStmt(db, `UPDATE ${quoteTable(p.table)} SET "${p.column}" = NULL WHERE "${p.column}" = '';`);
             }
         }
     }

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

@@ -1,6 +1,7 @@
 import { repo } from 'remult';
 import { getRelationFieldInfo } from 'remult/internals';
-import { stripIdent } from './ident';
+import { execStmt } from './catalog';
+import { quoteTable, stripIdent, tableKey, tableKeySql, USER_SCHEMA_SQL } from './ident';
 import { planDropColumns } from './planDropColumns';
 /**
  * Audit - and optionally drop a selected subset of - orphan columns: live DB
@@ -45,20 +46,20 @@ export async function dropColumns(db, entities, opts) {
                 continue; // computed, no stored column
             columns.push(stripIdent(field.dbName));
         }
-        known.push({ table: stripIdent(meta.dbName), columns });
+        known.push({ table: tableKey(meta.dbName), columns });
     }
     // Live columns per table from the catalog, in ordinal order.
     const res = await db.createCommand().execute(`
-		SELECT table_name, column_name
+		SELECT ${tableKeySql('table_schema', 'table_name')} AS table_key, column_name
 		FROM information_schema.columns
-		WHERE table_schema = 'public'
-		ORDER BY table_name, ordinal_position;
+		WHERE ${USER_SCHEMA_SQL('table_schema')}
+		ORDER BY table_key, ordinal_position;
 	`);
     const liveByTable = new Map();
     for (const row of res.rows) {
-        const list = liveByTable.get(row.table_name) ?? [];
+        const list = liveByTable.get(row.table_key) ?? [];
         list.push(row.column_name);
-        liveByTable.set(row.table_name, list);
+        liveByTable.set(row.table_key, list);
     }
     const current = Array.from(liveByTable, ([table, columns]) => ({ table, columns }));
     const plans = planDropColumns(current, known);
@@ -69,7 +70,7 @@ export async function dropColumns(db, entities, opts) {
         // raw client input, so the interpolated identifiers are trusted.
         dropped = opts.columns.filter((c) => orphan.has(`${c.table}.${c.column}`));
         for (const { table, column } of dropped) {
-            await db.createCommand().execute(`ALTER TABLE "${table}" DROP COLUMN "${column}";`);
+            await execStmt(db, `ALTER TABLE ${quoteTable(table)} DROP COLUMN "${column}";`);
         }
     }
     return { applied: opts?.apply ?? false, plans, dropped };

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

@@ -17,7 +17,7 @@ export type PkDesired = {
     table: string;
     cols: string[];
 };
-type PkAction = 'ok' | 'create' | 'migrate';
+type PkAction = 'ok' | 'create' | 'migrate' | 'missing';
 export type PkPlan = {
     table: string;
     before: string[];
@@ -30,7 +30,8 @@ export type PkPlan = {
  * in `desired` (firstly infra, views, etc.) are left alone - we only manage what
  * an entity's `id` config describes. Several entities can share one table (a
  * light projection + the full row on the same `dbName`) - one plan per table,
- * first declaration wins, so the UI can key rows by table.
+ * first declaration wins, so the UI can key rows by table. `tables` is every live
+ * table: an entity whose table was never created is `missing`, not a PK to add.
  */
-export declare function planPkSync(current: PkCurrent[], desired: PkDesired[]): PkPlan[];
+export declare function planPkSync(current: PkCurrent[], desired: PkDesired[], tables: ReadonlySet<string>): PkPlan[];
 export {};

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

@@ -1,11 +1,4 @@
-/**
- * Pure planner: diff the live PRIMARY KEYs against what the entity `id` config
- * wants, and emit the minimal ALTER plan. No DB access here - the controller
- * feeds it the catalog snapshot + the metadata-derived target, runs the SQL.
- *
- * Why this exists: Remult only sets a table's PK on first creation and never
- * ALTERs it, so a later `id` change is silently ignored on long-lived DBs.
- */
+import { quoteTable } from './ident';
 const ident = (name) => `"${name}"`;
 const cols = (names) => names.map(ident).join(', ');
 const sameOrder = (a, b) => a.length === b.length && a.every((c, i) => c === b[i]);
@@ -14,21 +7,24 @@ const sameOrder = (a, b) => a.length === b.length && a.every((c, i) => c === b[i
  * in `desired` (firstly infra, views, etc.) are left alone - we only manage what
  * an entity's `id` config describes. Several entities can share one table (a
  * light projection + the full row on the same `dbName`) - one plan per table,
- * first declaration wins, so the UI can key rows by table.
+ * first declaration wins, so the UI can key rows by table. `tables` is every live
+ * table: an entity whose table was never created is `missing`, not a PK to add.
  */
-export function planPkSync(current, desired) {
+export function planPkSync(current, desired, tables) {
     const byTable = new Map(current.map((c) => [c.table, c]));
     const seen = new Set();
     return desired.flatMap(({ table, cols: after }) => {
         if (seen.has(table))
             return [];
         seen.add(table);
+        if (!tables.has(table))
+            return [{ table, before: [], after, action: 'missing', sql: [] }];
         return [planTable(byTable.get(table), table, after)];
     });
 }
 function planTable(cur, table, after) {
     const before = cur?.cols ?? [];
-    const addPk = `ALTER TABLE ${ident(table)} ADD PRIMARY KEY (${cols(after)});`;
+    const addPk = `ALTER TABLE ${quoteTable(table)} ADD PRIMARY KEY (${cols(after)});`;
     if (!cur)
         return { table, before, after, action: 'create', sql: [addPk] };
     if (sameOrder(cur.cols, after))
@@ -38,6 +34,6 @@ function planTable(cur, table, after) {
         before,
         after,
         action: 'migrate',
-        sql: [`ALTER TABLE ${ident(table)} DROP CONSTRAINT ${ident(cur.constraintName)};`, addPk],
+        sql: [`ALTER TABLE ${quoteTable(table)} DROP CONSTRAINT ${ident(cur.constraintName)};`, addPk],
     };
 }

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

@@ -1,5 +1,6 @@
 import { repo } from 'remult';
-import { stripIdent } from './ident';
+import { execStmt, liveTables } from './catalog';
+import { stripIdent, tableKey, tableKeySql, USER_SCHEMA_SQL } from './ident';
 import { planPkSync } from './planPkSync';
 /**
  * Audit - and optionally fix - PRIMARY KEY drift between the live DB and each
@@ -19,21 +20,22 @@ import { planPkSync } from './planPkSync';
 export async function reindexPrimaryKeys(db, entities, opts) {
     // Live PKs from the catalog, columns kept in constraint order.
     const res = await db.createCommand().execute(`
-		SELECT tc.table_name, tc.constraint_name, kcu.column_name
+		SELECT ${tableKeySql('tc.table_schema', 'tc.table_name')} AS table_key,
+			tc.constraint_name, kcu.column_name
 		FROM information_schema.table_constraints tc
 		JOIN information_schema.key_column_usage kcu
 			ON tc.constraint_name = kcu.constraint_name
 			AND tc.table_schema = kcu.table_schema
 		WHERE tc.constraint_type = 'PRIMARY KEY'
-			AND tc.table_schema = 'public'
-		ORDER BY tc.table_name, kcu.ordinal_position;
+			AND ${USER_SCHEMA_SQL('tc.table_schema')}
+		ORDER BY table_key, kcu.ordinal_position;
 	`);
     const byTable = new Map();
     for (const row of res.rows) {
-        let cur = byTable.get(row.table_name);
+        let cur = byTable.get(row.table_key);
         if (!cur) {
-            cur = { table: row.table_name, constraintName: row.constraint_name, cols: [] };
-            byTable.set(row.table_name, cur);
+            cur = { table: row.table_key, constraintName: row.constraint_name, cols: [] };
+            byTable.set(row.table_key, cur);
         }
         cur.cols.push(row.column_name);
     }
@@ -46,14 +48,15 @@ export async function reindexPrimaryKeys(db, entities, opts) {
         const cols = meta.idMetadata.fields.map((f) => stripIdent(f.dbName));
         if (cols.length === 0)
             continue;
-        desired.push({ table: stripIdent(meta.dbName), cols });
+        desired.push({ table: tableKey(meta.dbName), cols });
     }
-    const plans = planPkSync([...byTable.values()], desired);
+    const tables = await liveTables(db);
+    const plans = planPkSync([...byTable.values()], desired, tables);
     if (opts?.apply) {
         for (const plan of plans) {
             // Fail-fast: any throw aborts the shared transaction -> full rollback.
             for (const stmt of plan.sql)
-                await db.createCommand().execute(stmt);
+                await execStmt(db, stmt);
         }
     }
     return { applied: opts?.apply ?? false, plans };

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

@@ -13,7 +13,7 @@ export type RelIndexPlan = {
     table: string;
     columns: string[];
     name: string;
-    action: 'ok' | 'create';
+    action: 'ok' | 'create' | 'missing';
     /** name of the index already covering these columns (when action is 'ok'). */
     coveredBy: string | null;
     sql: string | null;
@@ -22,9 +22,9 @@ export type RelIndexPlan = {
  * Pure: for each (deduped) relation FK, decide whether an index is missing.
  * A relation is already covered if any existing index - including the PRIMARY KEY -
  * has those columns as its leftmost prefix, so we never propose redundant indexes
- * (e.g. an `a` index on an `(a, b)` PK table).
+ * (e.g. an `a` index on an `(a, b)` PK table). A table never created is `missing`.
  */
-export declare function planRelationIndexes(desired: RelIndexDesired[], existing: Map<string, ExistingIndex[]>): RelIndexPlan[];
+export declare function planRelationIndexes(desired: RelIndexDesired[], existing: Map<string, ExistingIndex[]>, tables: ReadonlySet<string>): 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[]>;
 /**

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

@@ -1,16 +1,17 @@
 import { dbNamesOf, repo } from 'remult';
 import { getRelationFieldInfo } from 'remult/internals';
+import { execStmt, liveTables } from './catalog';
 import { formatCreateIndex } from './createIndex';
-import { stripIdent } from './ident';
+import { splitKey, stripIdent, tableKey, tableKeySql, USER_SCHEMA_SQL } from './ident';
 /** `want` is covered if it's a leftmost prefix of `have` (so the PK covers its own prefix). */
 const isPrefix = (want, have) => have.length >= want.length && want.every((c, i) => have[i] === c);
 /**
  * Pure: for each (deduped) relation FK, decide whether an index is missing.
  * A relation is already covered if any existing index - including the PRIMARY KEY -
  * has those columns as its leftmost prefix, so we never propose redundant indexes
- * (e.g. an `a` index on an `(a, b)` PK table).
+ * (e.g. an `a` index on an `(a, b)` PK table). A table never created is `missing`.
  */
-export function planRelationIndexes(desired, existing) {
+export function planRelationIndexes(desired, existing, tables) {
     const seen = new Set();
     const plans = [];
     for (const d of desired) {
@@ -19,6 +20,10 @@ export function planRelationIndexes(desired, existing) {
             continue;
         seen.add(key);
         const name = `FF_IX_${d.table}_${d.columns.join('_')}`;
+        if (!tables.has(d.table)) {
+            plans.push({ ...d, name, action: 'missing', coveredBy: null, sql: null });
+            continue;
+        }
         const cover = (existing.get(d.table) ?? []).find((e) => isPrefix(d.columns, e.cols));
         plans.push(cover
             ? { table: d.table, columns: d.columns, name, action: 'ok', coveredBy: cover.name, sql: null }
@@ -28,7 +33,12 @@ export function planRelationIndexes(desired, existing) {
                 name,
                 action: 'create',
                 coveredBy: null,
-                sql: formatCreateIndex({ name, table: d.table, columns: d.columns, ifNotExists: true }),
+                sql: formatCreateIndex({
+                    name,
+                    ...splitKey(d.table),
+                    columns: d.columns,
+                    ifNotExists: true,
+                }),
             });
     }
     return plans;
@@ -41,7 +51,7 @@ export async function relationIndexTargets(entities) {
         if (meta.options.sqlExpression)
             continue; // views: no real table
         const names = await dbNamesOf(ent);
-        const table = stripIdent(names.$entityName);
+        const table = tableKey(names.$entityName);
         for (const field of meta.fields.toArray()) {
             const fi = getRelationFieldInfo(field);
             if (!fi || fi.type !== 'toOne')
@@ -75,28 +85,29 @@ 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,
+		SELECT ${tableKeySql('ns.nspname', 'c.relname')} AS table_key, i.relname AS index_name,
 			array_agg(a.attname::text ORDER BY k.ord) AS cols
 		FROM pg_class c
-		JOIN pg_namespace ns ON ns.oid = c.relnamespace AND ns.nspname = 'public'
+		JOIN pg_namespace ns ON ns.oid = c.relnamespace AND ${USER_SCHEMA_SQL('ns.nspname')}
 		JOIN pg_index ix ON ix.indrelid = c.oid
 		JOIN pg_class i ON i.oid = ix.indexrelid
 		JOIN unnest(ix.indkey) WITH ORDINALITY AS k(attnum, ord) ON true
 		JOIN pg_attribute a ON a.attrelid = c.oid AND a.attnum = k.attnum
 		WHERE c.relkind = 'r' AND k.attnum > 0
-		GROUP BY c.relname, i.relname;
+		GROUP BY ns.nspname, c.relname, i.relname;
 	`);
     const existing = new Map();
     for (const row of res.rows) {
-        const list = existing.get(row.table_name) ?? [];
+        const list = existing.get(row.table_key) ?? [];
         list.push({ name: row.index_name, cols: row.cols });
-        existing.set(row.table_name, list);
+        existing.set(row.table_key, list);
     }
-    const plans = planRelationIndexes(desired, existing);
+    const tables = await liveTables(db);
+    const plans = planRelationIndexes(desired, existing, tables);
     if (opts?.apply) {
         for (const plan of plans)
             if (plan.sql)
-                await db.createCommand().execute(plan.sql);
+                await execStmt(db, plan.sql);
     }
     return { applied: opts?.apply ?? false, plans };
 }