@bakery-framework/orm 2.0.0-alpha.6 → 2.0.0-alpha.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bakery-framework/orm",
-  "version": "2.0.0-alpha.6",
+  "version": "2.0.0-alpha.8",
   "description": "Bakery database layer: adapters, query builder, schema sync and backup.",
   "keywords": [
     "bakery",
@@ -54,6 +54,6 @@
     "bun": ">=1.3.14"
   },
   "dependencies": {
-    "@bakery-framework/core": "^2.0.0-alpha.6"
+    "@bakery-framework/core": "^2.0.0-alpha.8"
   }
 }

package/src/adapters/pgsql.ts

@@ -253,59 +253,62 @@ export class PGAdapter extends SQLAdapter {
         " WHERE table_schema NOT IN ('pg_catalog', 'information_schema')" +
         ' ORDER BY table_name',
     ).all()) as any[]
-    const tablesWithDetails: SQLAdapter.TableDetails[] = []
-
-    for (const t of res) {
-      const qName = this.quote(t.name)
-      const [countRes, cols, pkCols, idxs] = (await Promise.all([
-        this.query(`SELECT COUNT(*)::int as count FROM ${qName}`).get(),
-        this.query(
-          'SELECT column_name AS name, data_type AS type,' +
-            ' is_nullable AS is_nullable' +
-            ' FROM information_schema.columns' +
-            ' WHERE table_name = ?' +
-            " AND table_schema NOT IN ('pg_catalog', 'information_schema')" +
-            ' ORDER BY ordinal_position',
-        ).all(t.name),
-        // `::regclass` casts a **string**, so the table name binds as a
-        // parameter. It used to interpolate `qName` — a double-quoted
-        // *identifier* — which Postgres reads as a column reference, so this
-        // threw `column "<table>" does not exist` for every table and took the
-        // whole of `getSchema()` down with it on this dialect.
-        //
-        // The quiet case was worse than the loud one: a table with a column of
-        // the same name resolved, casting that column's *value* to a regclass
-        // and reporting some other table's primary key as this one's.
-        this.query(
-          'SELECT a.attname AS name' +
-            ' FROM pg_index i' +
-            ' JOIN pg_attribute a ON a.attrelid = i.indrelid' +
-            ' AND a.attnum = ANY(i.indkey)' +
-            ' WHERE i.indisprimary AND i.indrelid = ?::regclass',
-        ).all(t.name),
-        this.query(
-          'SELECT indexname AS name, indexdef AS def' +
-            ' FROM pg_indexes' +
-            " WHERE schemaname NOT IN ('pg_catalog', 'information_schema')" +
-            ' AND tablename = ?',
-        ).all(t.name),
-      ])) as [SQLAdapter.CountRow, any[], any[], any[]]
-      tablesWithDetails.push({
-        name: t.name,
-        rowCount: countRes?.count || 0,
-        columns: cols.map(c => ({
-          name: c.name,
-          type: c.type,
-          notnull: c.is_nullable === 'NO',
-          pk: pkCols.some(pk => pk.name === c.name),
-        })),
-        indexes: idxs.map(i => ({
-          name: i.name,
-          unique: /UNIQUE/i.test(i.def),
-        })),
-      })
-    }
-    return tablesWithDetails
+    // One wave rather than N. The four queries per table were already
+    // concurrent; the loop around them awaited each table in turn, so a
+    // 20-table schema cost 20 sequential round-trip waves. See the note in
+    // sqlite.ts about the COUNT(*), which is a full scan here too.
+    return await Promise.all(
+      res.map(async t => {
+        const qName = this.quote(t.name)
+        const [countRes, cols, pkCols, idxs] = (await Promise.all([
+          this.query(`SELECT COUNT(*)::int as count FROM ${qName}`).get(),
+          this.query(
+            'SELECT column_name AS name, data_type AS type,' +
+              ' is_nullable AS is_nullable' +
+              ' FROM information_schema.columns' +
+              ' WHERE table_name = ?' +
+              " AND table_schema NOT IN ('pg_catalog', 'information_schema')" +
+              ' ORDER BY ordinal_position',
+          ).all(t.name),
+          // `::regclass` casts a **string**, so the table name binds as a
+          // parameter. It used to interpolate `qName` — a double-quoted
+          // *identifier* — which Postgres reads as a column reference, so this
+          // threw `column "<table>" does not exist` for every table and took the
+          // whole of `getSchema()` down with it on this dialect.
+          //
+          // The quiet case was worse than the loud one: a table with a column of
+          // the same name resolved, casting that column's *value* to a regclass
+          // and reporting some other table's primary key as this one's.
+          this.query(
+            'SELECT a.attname AS name' +
+              ' FROM pg_index i' +
+              ' JOIN pg_attribute a ON a.attrelid = i.indrelid' +
+              ' AND a.attnum = ANY(i.indkey)' +
+              ' WHERE i.indisprimary AND i.indrelid = ?::regclass',
+          ).all(t.name),
+          this.query(
+            'SELECT indexname AS name, indexdef AS def' +
+              ' FROM pg_indexes' +
+              " WHERE schemaname NOT IN ('pg_catalog', 'information_schema')" +
+              ' AND tablename = ?',
+          ).all(t.name),
+        ])) as [SQLAdapter.CountRow, any[], any[], any[]]
+        return {
+          name: t.name,
+          rowCount: countRes?.count || 0,
+          columns: cols.map(c => ({
+            name: c.name,
+            type: c.type,
+            notnull: c.is_nullable === 'NO',
+            pk: pkCols.some(pk => pk.name === c.name),
+          })),
+          indexes: idxs.map(i => ({
+            name: i.name,
+            unique: /UNIQUE/i.test(i.def),
+          })),
+        }
+      }),
+    )
   }
 
   async getData(

package/src/adapters/sqlite.ts

@@ -287,40 +287,50 @@ export class SQLiteAdapter extends SQLAdapter {
       'SELECT name FROM sqlite_master' +
         " WHERE type='table' AND name NOT LIKE 'sqlite_%'",
     ).all()) as SQLAdapter.NameRow[]
-    const tablesWithDetails: SQLAdapter.TableDetails[] = []
-    for (const t of res) {
-      const tableName = this.quote(t.name)
-
-      const [countRes, cols, idxs] = (await Promise.all([
-        this.query(`SELECT COUNT(*) as count FROM ${tableName}`).get(),
-        this.query(`PRAGMA table_info(${tableName})`).all(),
-        this.query(`PRAGMA index_list(${tableName})`).all(),
-      ])) as [SQLAdapter.CountRow, any[], any[]]
-
-      tablesWithDetails.push({
-        name: t.name,
-        rowCount: countRes?.count || 0,
-        columns: cols.map(c => ({
-          name: c.name,
-          type: c.type,
-          notnull: c.notnull === 1,
-          // `pk` is the column's **1-based position within the primary key**,
-          // not a boolean — `PRAGMA table_info` reports 0 for "not part of the
-          // key", 1 for the first key column, 2 for the second. So `=== 1`
-          // reported a composite `PRIMARY KEY (a, b)` as a single-column key on
-          // `a`, silently, and only on SQLite: MySQL reads `column_key = 'PRI'`
-          // and Postgres reads `pg_index.indisprimary`, both of which are set on
-          // every member.
-          //
-          // `parseConstraints` a few hundred lines down already had this right
-          // (`col.pk > 0`), which is why `getConstraints()` disagreed with
-          // `getSchema()` about the same table.
-          pk: c.pk > 0,
-        })),
-        indexes: idxs.map(i => ({ name: i.name, unique: i.unique === 1 })),
-      })
-    }
-    return tablesWithDetails
+    // Per table rather than per wave: the three queries below were already
+    // concurrent, but the loop around them awaited each table in turn, so a
+    // 20-table schema cost 20 sequential round-trip waves. They share nothing,
+    // so the whole fan-out is one wave now.
+    //
+    // Worth knowing before this grows: the `COUNT(*)` is a full scan on this
+    // dialect and on Postgres, and it is paid on every caller of `getSchema()`
+    // even though only a schema *listing* displays the number. Making it
+    // optional means `rowCount` has to admit it can be absent, which is a type
+    // change across every consumer — recorded rather than done here.
+    return await Promise.all(
+      res.map(async t => {
+        const tableName = this.quote(t.name)
+
+        const [countRes, cols, idxs] = (await Promise.all([
+          this.query(`SELECT COUNT(*) as count FROM ${tableName}`).get(),
+          this.query(`PRAGMA table_info(${tableName})`).all(),
+          this.query(`PRAGMA index_list(${tableName})`).all(),
+        ])) as [SQLAdapter.CountRow, any[], any[]]
+
+        return {
+          name: t.name,
+          rowCount: countRes?.count || 0,
+          columns: cols.map(c => ({
+            name: c.name,
+            type: c.type,
+            notnull: c.notnull === 1,
+            // `pk` is the column's **1-based position within the primary key**,
+            // not a boolean — `PRAGMA table_info` reports 0 for "not part of the
+            // key", 1 for the first key column, 2 for the second. So `=== 1`
+            // reported a composite `PRIMARY KEY (a, b)` as a single-column key on
+            // `a`, silently, and only on SQLite: MySQL reads `column_key = 'PRI'`
+            // and Postgres reads `pg_index.indisprimary`, both of which are set on
+            // every member.
+            //
+            // `parseConstraints` a few hundred lines down already had this right
+            // (`col.pk > 0`), which is why `getConstraints()` disagreed with
+            // `getSchema()` about the same table.
+            pk: c.pk > 0,
+          })),
+          indexes: idxs.map(i => ({ name: i.name, unique: i.unique === 1 })),
+        }
+      }),
+    )
   }
 
   async getData(