@pikku/migrator-sql 0.12.3 → 0.12.4

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @pikku/migrator-sql
 
+## 0.12.4
+
+### Patch Changes
+
+- 7262b4c: `db generate` now creates a referenced table before the one referencing it
+
 ## 0.12.3
 
 ### Patch Changes

package/dist/src/index.d.ts

@@ -10,4 +10,4 @@
  */
 export { migrate, baselineMigrations, pendingMigrations, MigrationDriftError, MIGRATION_TRACKING_TABLE, type MigrationExecutor, type MigrateResult, type AppliedMigration, } from './sql-migrator.js';
 export { assertSnakeCaseIdentifiers, findCamelCaseIdentifiers, stripSqlComments, CamelCaseIdentifierError, type CamelCaseIdentifier, } from './migration-identifiers.js';
-export { splitStatements, bareTableName, tableCreationSql, } from './schema-sql.js';
+export { splitStatements, bareTableName, tableCreationSql, tablesInSourceOrder, } from './schema-sql.js';

package/dist/src/index.js

@@ -10,4 +10,4 @@
  */
 export { migrate, baselineMigrations, pendingMigrations, MigrationDriftError, MIGRATION_TRACKING_TABLE, } from './sql-migrator.js';
 export { assertSnakeCaseIdentifiers, findCamelCaseIdentifiers, stripSqlComments, CamelCaseIdentifierError, } from './migration-identifiers.js';
-export { splitStatements, bareTableName, tableCreationSql, } from './schema-sql.js';
+export { splitStatements, bareTableName, tableCreationSql, tablesInSourceOrder, } from './schema-sql.js';

package/dist/src/schema-sql.d.ts

@@ -41,3 +41,14 @@ export declare function bareTableName(name: string): string;
  * expected to fall back rather than emit nothing.
  */
 export declare function tableCreationSql(sql: string, table: string): string[];
+/**
+ * `tables`, in the order `sql` creates them.
+ *
+ * A diff hands its missing tables back in whatever order it walked them, which
+ * is usually alphabetical and is never the order they can be created in: a
+ * table that references another has to come after it, and `channel_subscriptions`
+ * sorts before `channels`. The source's own SQL already has a workable order —
+ * it was applied in it — so that is the order used, with anything the source
+ * does not visibly create left at the end for the caller to render its own way.
+ */
+export declare function tablesInSourceOrder(sql: string, tables: string[]): string[];

package/dist/src/schema-sql.js

@@ -133,3 +133,27 @@ export function tableCreationSql(sql, table) {
     // and their presence says the table came from somewhere this cannot read.
     return creates ? statements : [];
 }
+/**
+ * `tables`, in the order `sql` creates them.
+ *
+ * A diff hands its missing tables back in whatever order it walked them, which
+ * is usually alphabetical and is never the order they can be created in: a
+ * table that references another has to come after it, and `channel_subscriptions`
+ * sorts before `channels`. The source's own SQL already has a workable order —
+ * it was applied in it — so that is the order used, with anything the source
+ * does not visibly create left at the end for the caller to render its own way.
+ */
+export function tablesInSourceOrder(sql, tables) {
+    const position = new Map();
+    let index = 0;
+    for (const statement of splitStatements(sql)) {
+        const create = CREATE_TABLE.exec(statement);
+        if (create) {
+            const name = bareTableName(create[1]);
+            if (!position.has(name))
+                position.set(name, index++);
+        }
+    }
+    const rank = (table) => position.get(bareTableName(table)) ?? Number.MAX_SAFE_INTEGER;
+    return [...tables].sort((a, b) => rank(a) - rank(b));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pikku/migrator-sql",
-  "version": "0.12.3",
+  "version": "0.12.4",
   "description": "The SQL migration applier shared by the Pikku CLI and the standalone runtime",
   "author": "yasser.fadl@gmail.com",
   "license": "MIT",

package/src/index.ts

@@ -31,4 +31,5 @@ export {
   splitStatements,
   bareTableName,
   tableCreationSql,
+  tablesInSourceOrder,
 } from './schema-sql.js'

package/src/schema-sql.test.ts

@@ -1,7 +1,11 @@
 import test from 'node:test'
 import assert from 'node:assert/strict'
 
-import { splitStatements, tableCreationSql } from './schema-sql.js'
+import {
+  splitStatements,
+  tableCreationSql,
+  tablesInSourceOrder,
+} from './schema-sql.js'
 
 test('a semicolon inside a string literal is not a statement boundary', () => {
   const sql = `CREATE TABLE a (id TEXT, note TEXT DEFAULT 'one; two');
@@ -64,3 +68,25 @@ CREATE INDEX "orphan_idx" ON "orders" ("id");`
 
   assert.deepEqual(tableCreationSql(sql, 'orders'), [])
 })
+
+test('a referencing table is created after the one it references, not alphabetically', () => {
+  const sql = `create table "channels" ("channel_id" text primary key);
+create table "channel_subscriptions" ("channel_id" text not null references "channels" ("channel_id"));`
+
+  assert.deepEqual(
+    tablesInSourceOrder(sql, ['channel_subscriptions', 'channels']),
+    ['channels', 'channel_subscriptions']
+  )
+})
+
+test('a table the source does not create is left at the end', () => {
+  const sql = 'create table "a" ("id" text);'
+  assert.deepEqual(tablesInSourceOrder(sql, ['unknown', 'a']), ['a', 'unknown'])
+})
+
+test('source order survives a schema qualifier on either side', () => {
+  const sql = `create table app."b" ("id" text);
+create table "a" ("id" text);`
+
+  assert.deepEqual(tablesInSourceOrder(sql, ['a', 'app.b']), ['app.b', 'a'])
+})

package/src/schema-sql.ts

@@ -153,3 +153,27 @@ export function tableCreationSql(sql: string, table: string): string[] {
   // and their presence says the table came from somewhere this cannot read.
   return creates ? statements : []
 }
+
+/**
+ * `tables`, in the order `sql` creates them.
+ *
+ * A diff hands its missing tables back in whatever order it walked them, which
+ * is usually alphabetical and is never the order they can be created in: a
+ * table that references another has to come after it, and `channel_subscriptions`
+ * sorts before `channels`. The source's own SQL already has a workable order —
+ * it was applied in it — so that is the order used, with anything the source
+ * does not visibly create left at the end for the caller to render its own way.
+ */
+export function tablesInSourceOrder(sql: string, tables: string[]): string[] {
+  const position = new Map<string, number>()
+  let index = 0
+  for (const statement of splitStatements(sql)) {
+    const create = CREATE_TABLE.exec(statement)
+    if (create) {
+      const name = bareTableName(create[1]!)
+      if (!position.has(name)) position.set(name, index++)
+    }
+  }
+  const rank = (table: string) => position.get(bareTableName(table)) ?? Number.MAX_SAFE_INTEGER
+  return [...tables].sort((a, b) => rank(a) - rank(b))
+}