@ultimabase/postgres 0.0.0-stage → 0.1.0

package/dist/write.d.ts

@@ -0,0 +1,17 @@
+import type { RawBuilder } from 'kysely';
+import type { Write } from 'ultimabase';
+import type { Catalog } from './names.ts';
+/** A statement of a write: how many checks its result carries, `c0`… */
+export type Statement = {
+    readonly sql: RawBuilder<{
+        readonly [column: string]: unknown;
+    }>;
+    readonly checks: number;
+};
+/** The statements of a write, in the order they run. */
+export declare function compileWrite(catalog: Catalog, write: Write, 
+/** Where the feed's notifications go, when it has a taker (D-154). */
+channel?: string): Statement[];
+/** A constraint's refusal as the kernel's error; any other as is. */
+export declare function translate(catalog: Catalog, error: unknown): unknown;
+//# sourceMappingURL=write.d.ts.map

package/dist/write.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"write.d.ts","sourceRoot":"","sources":["../src/write.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,QAAQ,CAAA;AAExC,OAAO,KAAK,EAAoC,KAAK,EAAE,MAAM,YAAY,CAAA;AAIzE,OAAO,KAAK,EAAE,OAAO,EAAS,MAAM,YAAY,CAAA;AAOhD,wEAAwE;AACxE,MAAM,MAAM,SAAS,GAAG;IACvB,QAAQ,CAAC,GAAG,EAAE,UAAU,CAAC;QAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAA;KAAE,CAAC,CAAA;IAChE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CACvB,CAAA;AAyMD,wDAAwD;AACxD,wBAAgB,YAAY,CAC3B,OAAO,EAAE,OAAO,EAChB,KAAK,EAAE,KAAK;AACZ,sEAAsE;AACtE,OAAO,CAAC,EAAE,MAAM,GACd,SAAS,EAAE,CAsHb;AAkBD,qEAAqE;AACrE,wBAAgB,SAAS,CAAC,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,GAAG,OAAO,CAenE"}

package/dist/write.js

@@ -0,0 +1,296 @@
+import { sql } from 'kysely';
+import { RelationViolation, UniqueViolation } from 'ultimabase';
+import { Filters, uuid, value } from './filter.js';
+import { computed } from './numbers.js';
+import { fieldsOf, grouped, inserted, sizeOf } from './parts.js';
+import { notifying, pairs as linked, rows as noted } from './notify.js';
+import { compileRows } from './read.js';
+function assignments(catalog, table, values) {
+    return Object.entries(values)
+        .filter(([, item]) => item !== undefined)
+        .map(([name, item]) => [
+        catalog.column(table, name),
+        value(catalog.kind(table, name), item),
+    ]);
+}
+const and = (gate) => gate === undefined ? sql `` : sql ` and ${gate}`;
+/** The id a filter selects by `{ id: { equals } }` alone, if any. */
+function idOf(where) {
+    if (where === undefined || Object.keys(where).length !== 1)
+        return undefined;
+    const id = where['id'];
+    if (typeof id !== 'object' || id === null || Object.keys(id).length !== 1) {
+        return undefined;
+    }
+    return 'equals' in id && typeof id.equals === 'string' ? id.equals : undefined;
+}
+/** The CTE of a change, `undefined` when it changes nothing. */
+function part(catalog, change, removed) {
+    if (change.kind !== 'update' && change.kind !== 'delete') {
+        return links(catalog, change);
+    }
+    const table = catalog.table(change.model);
+    const name = sql.id(table.name);
+    const base = { table: table.name, key: ['id'] };
+    const filters = new Filters(catalog, removed);
+    const named = filters.alias();
+    const alias = sql.id(named);
+    const where = filters.where(change.model, named, change.where);
+    const reads = new Set([table.name, ...filters.tables]);
+    if (change.kind === 'update') {
+        const fields = [
+            ...Object.keys(change.set),
+            ...Object.keys(change.compute ?? {}),
+        ];
+        const set = sql.join([
+            ...assignments(catalog, table, change.set).map(([column, item]) => sql `${sql.id(column)} = ${item}`),
+            ...computed(catalog, table, change.compute),
+        ]);
+        const row = idOf(change.where);
+        return {
+            ...base,
+            ...(row === undefined ? {} : { row }),
+            build: (gate) => sql `update ${name} as ${alias} set ${set} where ${where}${and(gate)} returning ${alias}.*`,
+            inserts: false,
+            removes: true,
+            adds: true,
+            reads,
+            noted: noted('update', change.model, fields),
+        };
+    }
+    return {
+        ...base,
+        build: (gate) => sql `delete from ${name} as ${alias} where ${where}${and(gate)} returning ${alias}.*`,
+        inserts: false,
+        removes: true,
+        adds: false,
+        reads,
+        noted: noted('delete', change.model),
+    };
+}
+/** A link or unlink of nothing, or of ids no row has, changes nothing. */
+function links(catalog, change) {
+    const join = catalog.join(change.model, change.field);
+    const name = sql.id(join.table);
+    const self = sql.id(join.self);
+    const other = sql.id(join.other);
+    const key = [join.self, join.other].toSorted();
+    const id = sql `cast(${change.id} as uuid)`;
+    // The same pair, whichever side names it.
+    const pairOf = (target) => key[0] === join.self ? `${change.id}:${target}` : `${target}:${change.id}`;
+    const pairs = (targets) => ({
+        table: join.table,
+        key,
+        reads: new Set(),
+        pairs: new Set(targets.map(pairOf)),
+        noted: linked(change.kind, change.model, change.field, join.self, join.other),
+    });
+    if (change.kind === 'unlink') {
+        const targets = change.targets.filter((target) => uuid.test(target));
+        if (targets.length === 0)
+            return undefined;
+        const list = sql.join(targets.map((target) => sql `cast(${target} as uuid)`));
+        return {
+            ...pairs(targets),
+            build: (gate) => sql `delete from ${name} where ${self} = ${id} and ${other} in (${list})${and(gate)} returning *`,
+            inserts: false,
+            removes: true,
+            adds: false,
+        };
+    }
+    if (change.targets.length === 0)
+        return undefined;
+    const rows = sql.join(change.targets.map((target) => sql `(${id}, cast(${target} as uuid))`));
+    return {
+        ...pairs(change.targets),
+        build: (gate) => {
+            const source = gate === undefined
+                ? sql `values ${rows}`
+                : sql `select * from (values ${rows}) as "v" where ${gate}`;
+            return sql `insert into ${name} (${self}, ${other}) ${source} on conflict do nothing returning *`;
+        },
+        inserts: true,
+        removes: false,
+        adds: true,
+    };
+}
+function checking(catalog, checks) {
+    const filters = new Filters(catalog);
+    const columns = checks.map((check, at) => {
+        const table = sql.id(catalog.table(check.model).name);
+        const alias = filters.alias();
+        const where = filters.where(check.model, alias, check.where);
+        // A locked row is counted as it is after any wait for its lock.
+        const rows = sql `${table} as ${sql.id(alias)} where ${where}`;
+        const from = check.lock ? sql `(select from ${rows} for update) as t` : rows;
+        return sql `(select count(*) from ${from}) = ${check.count} as ${sql.id(`c${at}`)}`;
+    });
+    return sql `select ${sql.join(columns)}`;
+}
+const cteName = (at) => `#w${at}`;
+const cte = (at) => sql.id(cteName(at));
+/** Each written table as the read sees it: the changed rows in place. */
+function views(parts) {
+    const tables = new Map();
+    for (const [at, each] of parts) {
+        tables.set(each.table, [...(tables.get(each.table) ?? []), [at, each]]);
+    }
+    return [...tables].map(([table, written]) => {
+        const name = sql.id(table);
+        const key = written[0]?.[1].key ?? [];
+        const keys = sql.join(key.map((column) => sql.id(column)));
+        const removed = written
+            .filter(([, each]) => each.removes)
+            .map(([at]) => sql `select ${keys} from ${cte(at)}`);
+        const kept = removed.length === 0
+            ? sql `select * from ${name}`
+            : sql `select * from ${name} where (${keys}) not in (${sql.join(removed, sql ` union all `)})`;
+        const added = written
+            .filter(([, each]) => each.adds)
+            .map(([at]) => sql `select * from ${cte(at)}`);
+        const body = sql.join([kept, ...added], sql ` union all `);
+        return sql `${name} as not materialized (${body})`;
+    });
+}
+/**
+ * The change of a statement that writes the one row `read` selects, when no
+ * other change of it writes that table: the read takes the row from its
+ * RETURNING rather than from the table's view (D-103).
+ */
+function sourceOf(catalog, read, parts) {
+    const id = idOf(read.where);
+    const table = catalog.table(read.model).name;
+    const written = [...parts].filter(([, each]) => each.table === table);
+    const [only] = written;
+    return id !== undefined && written.length === 1 && only?.[1].row === id
+        ? only[0]
+        : undefined;
+}
+/** The statements of a write, in the order they run. */
+export function compileWrite(catalog, write, 
+/** Where the feed's notifications go, when it has a taker (D-154). */
+channel) {
+    const checks = write.checks ?? [];
+    // Each statement stays within PostgreSQL's 65,535 parameters, its checks
+    // and its read's aside.
+    const room = 65_535 -
+        sizeOf(checking(catalog, checks)) -
+        (write.read === undefined
+            ? 0
+            : sizeOf(compileRows(catalog, write.read, undefined).rows));
+    const parts = [];
+    const removed = new Map();
+    // Consecutive rows of a table, setting the same fields, go in one insert.
+    let batch;
+    const flush = () => {
+        if (batch !== undefined) {
+            parts.push(inserted(catalog, batch.model, batch.rows));
+        }
+        batch = undefined;
+    };
+    for (const [index, change] of write.changes.entries()) {
+        if (change.kind === 'insert') {
+            const fields = fieldsOf(change.row);
+            const joins = batch?.model === change.model &&
+                fieldsOf(batch.rows[0] ?? {})
+                    .toSorted()
+                    .join() === fields.toSorted().join() &&
+                (batch.rows.length + 1) * fields.length <= room;
+            if (!joins) {
+                flush();
+                batch = { model: change.model, rows: [] };
+            }
+            batch?.rows.push(change.row);
+            continue;
+        }
+        flush();
+        const each = part(catalog, change, removed);
+        if (each === undefined)
+            continue;
+        if (change.kind === 'delete')
+            removed.set(index, cteName(parts.length));
+        parts.push(each);
+    }
+    flush();
+    if (parts.length === 0 && checks.length === 0 && write.read === undefined) {
+        return [];
+    }
+    const columns = checks.map((_, at) => sql.id(`c${at}`));
+    const gate = checks.length === 0
+        ? undefined
+        : sql `(select ${sql.join(columns, sql ` and `)} from "#checks")`;
+    const groups = grouped(parts, room);
+    const before = write.before === true;
+    const table = write.read && catalog.table(write.read.model).name;
+    // With `before`, the read runs beside its model's delete (D-104), or,
+    // when the write deletes nothing of it, its update (D-133).
+    const of = (adds) => parts.findIndex((each) => before && each.table === table && each.removes && each.adds === adds);
+    const deleted = of(false);
+    const removal = deleted === -1 ? of(true) : deleted;
+    let next = 0;
+    return groups.map((group, index) => {
+        const first = index === 0 && checks.length > 0;
+        const numbered = new Map(group.map((each) => [next++, each]));
+        const ctes = [...numbered].map(([at, each]) => sql `${cte(at)} as (${each.build(first ? gate : undefined)})`);
+        const reads = before ? numbered.has(removal) : index === groups.length - 1;
+        const read = reads ? write.read : undefined;
+        const seen = read !== undefined && !before;
+        const source = seen ? sourceOf(catalog, read, numbered) : removal;
+        const compiled = read === undefined
+            ? undefined
+            : compileRows(catalog, read, source === undefined ? undefined : cte(source));
+        const fed = channel !== undefined && numbered.size > 0;
+        const selected = [
+            ...(first ? columns : []),
+            ...(compiled === undefined ? [] : [sql `${compiled.rows} as "rows"`]),
+            // Referenced, the CTE runs.
+            ...(fed ? [sql `(select count(*) from "#feed") as "fed"`] : []),
+        ];
+        // The root's table needs no view when only its RETURNING is read.
+        const root = read === undefined ? '' : catalog.table(read.model).name;
+        const viewed = [...numbered].filter(([, each]) => source === undefined ||
+            each.table !== root ||
+            compiled?.tables.has(root) === true);
+        const all = [
+            ...(first ? [sql `"#checks" as (${checking(catalog, checks)})`] : []),
+            ...ctes,
+            ...(seen ? views(new Map(viewed)) : []),
+            ...(fed
+                ? [
+                    notifying(channel, [...numbered].map(([at, each]) => [cte(at), each.noted])),
+                ]
+                : []),
+        ];
+        const list = selected.length === 0 ? sql `1 as "one"` : sql.join(selected);
+        const body = sql `select ${list}${first ? sql ` from "#checks"` : sql ``}`;
+        return {
+            sql: all.length === 0 ? sql `${body}` : sql `with ${sql.join(all)} ${body}`,
+            checks: first ? checks.length : 0,
+        };
+    });
+}
+function isRefusal(error) {
+    return (error instanceof Error &&
+        'code' in error &&
+        typeof error.code === 'string' &&
+        'constraint' in error &&
+        typeof error.constraint === 'string');
+}
+/** A constraint's refusal as the kernel's error; any other as is. */
+export function translate(catalog, error) {
+    if (!isRefusal(error))
+        return error;
+    if (error.code === '23505') {
+        const unique = catalog.uniques.get(error.constraint);
+        if (unique !== undefined) {
+            return new UniqueViolation(unique.model, unique.fields);
+        }
+    }
+    const key = catalog.foreignKeys.get(error.constraint);
+    if (error.code === '23503' && key !== undefined) {
+        // Only the message tells the deleting side from the linking one.
+        const restricted = error.message.startsWith('update or delete');
+        return new RelationViolation(key.model, key.field, key.target, restricted);
+    }
+    return error;
+}

package/package.json

@@ -1,6 +1,48 @@
 {
   "name": "@ultimabase/postgres",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.1.0",
+  "description": "The PostgreSQL adapter for UltimaBase.",
+  "type": "module",
+  "license": "Apache-2.0",
+  "homepage": "https://ultimabase.dev/docs/postgres",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/MrEkinox/ultimabase.git",
+    "directory": "packages/postgres"
+  },
+  "engines": {
+    "node": ">=24.7.0"
+  },
+  "exports": {
+    ".": "./dist/index.js"
+  },
+  "files": [
+    "dist",
+    "src",
+    "!src/**/*.test.ts",
+    "!src/test"
+  ],
+  "scripts": {
+    "prepack": "rm -rf dist && yarn run -T tsc --project tsconfig.build.json"
+  },
+  "publishConfig": {
+    "exports": {
+      ".": "./dist/index.js"
+    }
+  },
+  "dependencies": {
+    "kysely": "0.29.6",
+    "pg": "8.23.1",
+    "pg-connection-string": "2.14.1"
+  },
+  "peerDependencies": {
+    "ultimabase": "^0.1.0"
+  },
+  "devDependencies": {
+    "@types/pg": "8.23.1",
+    "@ultimabase/testing": "0.1.0",
+    "ultimabase": "0.1.0",
+    "vite": "8.3.4",
+    "vitest": "5.0.5"
+  }
 }