okmodel 0.1.0 → 0.1.1

package/README.md

@@ -1,44 +1,246 @@
 # OKModel
 
-Catalog-first TypeScript ORM for PostgreSQL. Version 0.1.
+okmodel is a catalog-first TypeScript ORM, PostgreSQL first. Other SQL databases are the direction. Version 0.1 supports PostgreSQL only. The schema is the single source. Migrations and queries come from it.
+
+Version 0.1.1. Apache-2.0.
+
+## Contents
+
+- [Install](#install)
+- [Quickstart](#quickstart)
+  - [Configure](#configure)
+  - [Schema](#schema)
+  - [Push](#push)
+  - [Reviewed migrations](#reviewed-migrations)
+  - [One client](#one-client)
+  - [Insert](#insert)
+  - [Find](#find)
+  - [Errors](#errors)
+  - [Close](#close)
+- [Commands](#commands)
+- [Roadmap](#roadmap)
+- [Size](#size)
+- [Docs](#docs)
 
 ## Install
 
+Install okmodel and the postgres.js driver.
+
 ```sh
-bun add okmodel
+bun add okmodel postgres
 ```
 
-postgres.js and PGlite are optional peers. Install the one you connect with.
+PGlite is the in-process driver.
 
 ```sh
-bun add postgres
-# or
-bun add @electric-sql/pglite
+bun add okmodel @electric-sql/pglite
 ```
 
-The repository docs have the [quickstart](docs/quickstart.md), the [production checklist](docs/production.md), and the [known limits](docs/known-limits.md). Those files are not in the npm tarball.
+okmodel has no runtime dependencies. The driver is a peer.
+
+## Quickstart
+
+`DATABASE_URL` is a direct Postgres URL, not a pooler. The client, insert, find, and error blocks are one script, `run.ts`. `script.ts` is the `await using` form. The last block calls `db.close()`.
+
+### Configure
+
+Point the CLI at the schema and at that URL.
+
+`okmodel.config.ts`:
 
 ```ts
-import { schema, table, t } from "okmodel/pg";
 import { defineConfig } from "okmodel/migrate";
 
-export const notes = table("notes", {
-  id: t.uuid(),
-  title: t.text(),
+const url = process.env.DATABASE_URL;
+if (url === undefined || url.length === 0) {
+  throw new Error("DATABASE_URL is not set");
+}
+
+export default defineConfig({
+  schema: "./schema.ts",
+  database: url,
 });
+```
+
+### Schema
+
+`t.identity()` is the primary key. An insert omits the id, and the row that comes back carries it. Identity ids come back as strings by default. `t.identity({ as: "number" })` returns numbers. Push and reviewed migrations are two ways to do the same job: pick one per database.
+
+Tested on PostgreSQL 15 to 18.
+
+`schema.ts`:
+
+```ts
+import { one, schema, table, t } from "okmodel/pg";
+
+const authors = table("authors", {
+  id: t.identity(),
+  name: t.text().unique(),
+});
+
+const notes = table(
+  "notes",
+  {
+    id: t.identity(),
+    title: t.text(),
+    authorId: t.bigint().references("authors", { columns: ["id"] }),
+  },
+  { relations: { author: one("authors") } },
+);
 
-export const app = schema({ tables: [notes] });
+const tables = [authors, notes];
 
-export default defineConfig({ schema: "./schema.ts" });
+export default schema({ tables });
 ```
 
+### Push
+
+Create the tables with push, which is allowed because this target is not protected.
+
+```sh
+bunx okm push
+```
+
+A protected target refuses push. Production settings are in the [production checklist](https://github.com/omqkhafi/okmodel/blob/main/docs/production.md).
+
+### Reviewed migrations
+
+Generate writes a SQL file and `.okm`, and apply runs that file later so you can read the migration first.
+
 ```sh
-bunx okm build
 bunx okm generate init
+bunx okm migrate apply
+```
+
+### One client
+
+This module is cached, so the process has one client.
+
+`db.ts`:
+
+```ts
+import { connect } from "okmodel/pg/postgresjs";
+
+import schema from "./schema.ts";
+
+const url = process.env.DATABASE_URL;
+if (url === undefined || url.length === 0) throw new Error("DATABASE_URL is not set");
+
+export const db = connect(url, { schema });
+```
+
+### Insert
+
+Insert an author, then a note that points at the author's id.
+
+```ts
+import { db } from "./db.ts";
+
+const author = await db.authors.insert({ name: "Ada" });
+const note = await db.notes.insert({
+  title: "hello",
+  authorId: author.id,
+});
+if (author.name !== "Ada" || note.title !== "hello" || author.id.length === 0) {
+  throw new Error("insert did not return the row");
+}
+```
+
+### Find
+
+Load that note and its author by the id the insert returned.
+
+```ts
+const found = await db.notes.find({
+  where: { id: note.id },
+  limit: 5,
+  include: { author: true },
+});
+const row = found[0];
+if (row?.title !== "hello" || row.author?.name !== "Ada") {
+  throw new Error("find did not return the note and its author");
+}
+```
+
+### Errors
+
+`safe` returns the `OkmError` instead of throwing when the author name is already used.
+
+```ts
+import { OkmError, safe } from "okmodel";
+
+const duplicate = await safe(db.authors.insert({ name: "Ada" }));
+if (duplicate.ok || !(duplicate.error instanceof OkmError) || duplicate.error.kind !== "unique") {
+  throw new Error("expected an OkmError of kind unique");
+}
 ```
 
-`table` and `index` for a schema come from `okmodel/pg`. Stable, experimental, and internal exports are listed in `tests/fixtures/api-surface.json` in the repository. `okmodel/internal` has no stability promise.
+### Close
+
+A script exits when its queries finish. It does not need `close()` for that. `await using` closes the pool at the end of the block. `db.close()` is that call on a line you choose. A server keeps the client and its connections. A pool opened with `ssl` still waits out the driver's 30 second idle timer.
+
+`script.ts`:
+
+```ts
+import { connect } from "okmodel/pg/postgresjs";
+
+import schema from "./schema.ts";
+
+const url = process.env.DATABASE_URL;
+if (url === undefined || url.length === 0) throw new Error("DATABASE_URL is not set");
+
+await using db = connect(url, { schema });
+const author = await db.authors.insert({ name: "Lin" });
+if (author.name !== "Lin" || author.id.length === 0) {
+  throw new Error("insert did not return the row");
+}
+```
+
+```ts
+await db.close();
+```
+
+## Commands
+
+| Command                   | What it does                                                                                                                 |
+| ------------------------- | ---------------------------------------------------------------------------------------------------------------------------- |
+| `okm build`               | Validates the schema and writes `.okm/` (catalog, hash, emitted row types). `okm generate` writes those files too.           |
+| `okm check`               | Reports a stale `renamedFrom` and a table file the schema does not import.                                                   |
+| `okm generate [name]`     | Writes a SQL migration and `.okm/`. The name defaults to `migration`. Prints `no changes` when the schema matches.           |
+| `okm dev`                 | Uses a target named `dev`, or creates a PGlite database in `.okm/dev-db`. It does not apply migrations or write the catalog. |
+| `okm push`                | Applies the schema directly. Refused when the target is protected.                                                           |
+| `okm migrate plan <name>` | Prints the plan and its class. The name is required.                                                                         |
+| `okm migrate apply`       | Replays migration files on the database.                                                                                     |
+| `okm migrate status`      | Prints version, catalog hash, and state for each target.                                                                     |
+| `okm --version`           | Prints the package version.                                                                                                  |
+
+`okmodel` and `okm` are the same command.
+
+## Roadmap
+
+- [x] 0.1 — Schema, queries, and migrations on PostgreSQL, with postgres.js and PGlite.
+- [ ] 0.2 — Hidden and sensitive fields, validation, traits, tenancy, archive and restore, richer relations, presets, transactions, and operators for JSON, arrays, ranges, and search.
+- [ ] 0.3 — Extensions, domains, functions, triggers, views, roles, and grants.
+- [ ] 0.4 — Safer migration plans, backfill, drift checks, provisioning, reference data, and a testing package.
+- [ ] 0.5 — A primary with replicas, read routing, and a reference app.
+
+`okmodel/internal` has no stability promise. Names on that subpath can change or disappear in any release.
+
+Each limit, with the version that lifts it, is in [known limits](https://github.com/omqkhafi/okmodel/blob/main/docs/known-limits.md).
+
+## Size
+
+Measured on this release.
+
+|                                   | Minified |   Gzip | Cold import |
+| --------------------------------- | -------: | -----: | ----------: |
+| Runtime entry                     |    5,525 |  2,042 |    1.758 ms |
+| App startup (10 tables, one find) |   77,537 | 25,625 |    9.922 ms |
+
+The rest of the measurements are in [size](https://github.com/omqkhafi/okmodel/blob/main/docs/size.md).
 
-A production target sets `protected: true`. A production `connect` sets `requireMeta: true`. `prepared: "named"` is not for a transaction-mode pooler.
+## Docs
 
-Apache-2.0.
+- [Quickstart](https://github.com/omqkhafi/okmodel/blob/main/docs/quickstart.md)
+- [Production checklist](https://github.com/omqkhafi/okmodel/blob/main/docs/production.md)
+- [Known limits](https://github.com/omqkhafi/okmodel/blob/main/docs/known-limits.md)

package/dist/runtime/pg/pglite.js

@@ -6,7 +6,7 @@ import {
 } from "../../shared/fgqgsb5z.js";
 import {
   createClient
-} from "../../shared/f5thc1s0.js";
+} from "../../shared/rgs0st28.js";
 import {
   PGLITE_CAPABILITIES,
   readCapability2,

package/dist/runtime/pg/postgresjs.js

@@ -3,10 +3,10 @@ import {
 } from "../../shared/hd293j9g.js";
 import {
   open2
-} from "../../shared/7ck0dtry.js";
+} from "../../shared/dkn3y60a.js";
 import {
   createClient
-} from "../../shared/f5thc1s0.js";
+} from "../../shared/rgs0st28.js";
 import {
   POSTGRESJS_CAPABILITIES,
   readCapability2,

package/dist/runtime/types.d.ts

@@ -305,17 +305,33 @@ export type TableApi<S extends QuerySchema, K extends keyof S["~byName"] & strin
         readonly where?: WhereOf<S, K>;
     }, options?: WriteOptions<S, K>): Write<WriteCount>;
 };
+/**
+ * `[Symbol.asyncDispose]` when `Symbol` defines it.
+ *
+ * The check stays in the built declaration. A consumer `lib` without
+ * `asyncDispose` does not see the method, including with `skipLibCheck` off.
+ */
+type IfAsyncDisposable<S> = S extends {
+    readonly asyncDispose: infer D;
+} ? D extends symbol ? {
+    [K in D]: () => Promise<void>;
+} : object : object;
 /** A client typed by its own schema. */
 export type Connected<S extends QuerySchema> = {
     readonly [K in keyof S["~byName"] & string]: TableApi<S, K>;
 } & {
     /** Looks up a table by name. An unknown name is OKM1120. */
     table<K extends keyof S["~byName"] & string>(name: K): TableApi<S, K>;
-    /** Closes the pool when this client opened it. */
+    /**
+     * Closes the pool when this client opened it.
+     *
+     * A second call waits on the same close. A client that adopted a pool
+     * resolves without closing it.
+     */
     close(): Promise<void>;
     /** Resolves when the dialect and `requires` checks have finished. */
     readonly connected: Promise<void>;
-};
+} & IfAsyncDisposable<typeof Symbol>;
 /**
  * A catalog `okm build` wrote.
  *

package/dist/shared/{kynx7vbm.js → 05w44d8g.js}

@@ -253,6 +253,8 @@ function planMigration(request) {
   const enums = enumEdits(beforeBy, afterBy, schema);
   requireReplacements(picklists, enums, replacements);
   recreateDependents(beforeList, afterList, alters, dropKeys, createKeys, picklists);
+  omitOwnedSequences(createKeys, afterBy, request.after);
+  omitOwnedSequences(dropKeys, beforeBy, renamed);
   const steps = [];
   steps.push(...renameSteps(request.before, renames, schema));
   steps.push(...keptNames.map((item) => renameShapeStep(item, schema)));
@@ -284,6 +286,9 @@ function planMigration(request) {
     for (const sql of alterColumnSql(change.before, change.after, schema)) {
       steps.push(step(sql, alterClass(sql), "ddl", ACCESS));
     }
+    const identitySql = identityChangeSql(change.before, change.after, schema);
+    if (identitySql !== undefined)
+      steps.push(step(identitySql, "expand", "ddl", ACCESS));
   }
   const createdTables = new Set([...createKeys].map((key) => afterBy.get(key)).filter((object) => object?.kind === "table").map((object) => object.identity.name));
   const emitted = new Set;
@@ -875,7 +880,29 @@ function columnNullable(source, table, column) {
   return false;
 }
 function columnAlterable(before, after) {
-  return stable(before.definition.identity) === stable(after.definition.identity) && stable(before.definition.generated) === stable(after.definition.generated);
+  return stable(before.definition.generated) === stable(after.definition.generated);
+}
+function identityChangeSql(before, after, schema) {
+  if (stable(before.definition.identity) === stable(after.definition.identity))
+    return;
+  const table = qualify2(schema, after.identity.parent.name);
+  const name = quoteIdent(after.identity.name);
+  const next = after.definition.identity;
+  const previous = before.definition.identity;
+  if (next === undefined)
+    return `alter table ${table} alter column ${name} drop identity`;
+  if (previous === undefined) {
+    const generated = next.always ? "always" : "by default";
+    return `alter table ${table} alter column ${name} add generated ${generated} as identity`;
+  }
+  return `alter table ${table} alter column ${name} set generated ${next.always ? "always" : "by default"}`;
+}
+function omitOwnedSequences(keys, by, source) {
+  for (const key of keys) {
+    const object = by.get(key);
+    if (object?.kind === "sequence" && folded(object, source))
+      keys.delete(key);
+  }
 }
 function sameDefinition(left, right) {
   return stable(left.definition) === stable(right.definition);
@@ -894,9 +921,16 @@ function folded(object, source) {
     return true;
   if (object.kind === "constraint" && object.definition.constraintKind === "primaryKey")
     return true;
-  if (object.kind === "sequence" && identitySequence(object, source))
+  if (object.kind !== "sequence")
+    return false;
+  if (identitySequence(object, source))
     return true;
-  return false;
+  const name = object.identity.name;
+  return source.objects.some((column) => {
+    if (column.kind !== "column" || column.definition.identity === undefined)
+      return false;
+    return name === `${column.identity.parent.name}_${column.identity.name}_seq`;
+  });
 }
 function anchoredParent(object) {
   if (object.kind === "column" || object.kind === "index" || object.kind === "constraint") {

package/dist/shared/{ax16zpvm.js → 523ft3e8.js}

@@ -1,15 +1,15 @@
 import {
   open2
-} from "./7ck0dtry.js";
+} from "./dkn3y60a.js";
 import"./y9m15dfv.js";
 import {
   loadMigrations
-} from "./4j72449d.js";
+} from "./jjb7yht9.js";
 import {
   assertTargetPolicy,
   listTargets,
   loadConfig
-} from "./kynx7vbm.js";
+} from "./05w44d8g.js";
 import {
   OkmError2
 } from "./ycwz42az.js";

package/dist/shared/{7ck0dtry.js → dkn3y60a.js}

@@ -10,7 +10,119 @@ import {
 } from "./xy79j5hq.js";
 
 // src/adapters/pg/postgresjs.ts
+import net from "node:net";
 import postgres from "postgres";
+class PoolSockets {
+  held = [];
+  busy = 0;
+  listeners = 0;
+  hostCursor = 0;
+  connect(target) {
+    const path = typeof target.path === "string" ? target.path : undefined;
+    const hosts = target.host;
+    const ports = target.port;
+    const index = hosts.length === 0 ? 0 : this.hostCursor % hosts.length;
+    this.hostCursor += 1;
+    const host = hosts[index] ?? "localhost";
+    const port = ports[index] ?? ports[0] ?? 5432;
+    const socket = path !== undefined ? net.connect(path) : net.connect(port, host);
+    this.held.push(socket);
+    return socket;
+  }
+  occupy(run) {
+    this.busy += 1;
+    this.wake();
+    return run().finally(() => {
+      this.busy -= 1;
+      this.park();
+    });
+  }
+  async hold(checkout) {
+    this.busy += 1;
+    this.wake();
+    try {
+      const connection = await checkout();
+      let released = false;
+      const release = connection.release.bind(connection);
+      connection.release = () => {
+        if (released)
+          return Promise.resolve();
+        released = true;
+        return release().finally(() => {
+          this.busy -= 1;
+          this.park();
+        });
+      };
+      return connection;
+    } catch (error) {
+      this.busy -= 1;
+      this.park();
+      throw error;
+    }
+  }
+  async* stream(open) {
+    this.busy += 1;
+    this.wake();
+    try {
+      yield* open();
+    } finally {
+      this.busy -= 1;
+      this.park();
+    }
+  }
+  async listen(start) {
+    this.listeners += 1;
+    this.wake();
+    try {
+      const stop = await start();
+      let stopped = false;
+      return async () => {
+        if (stopped)
+          return;
+        stopped = true;
+        try {
+          await stop();
+        } finally {
+          this.listeners -= 1;
+          this.park();
+        }
+      };
+    } catch (error) {
+      this.listeners -= 1;
+      this.park();
+      throw error;
+    }
+  }
+  wake() {
+    for (const socket of this.held)
+      socket.ref();
+  }
+  park() {
+    if (this.busy > 0 || this.listeners > 0)
+      return;
+    for (const socket of this.held)
+      socket.unref();
+  }
+}
+function driverOptions(config, state) {
+  return {
+    max: state.max,
+    prepare: state.named,
+    idle_timeout: state.plain ? 0 : 30,
+    ...state.plain ? { max_lifetime: null } : {},
+    connect_timeout: 5,
+    types: WIRE_TYPES,
+    ...state.plain ? { socket: (options) => state.sockets.connect(options) } : {},
+    ...config.ssl !== undefined ? { ssl: config.ssl } : {},
+    connection: {
+      application_name: "okmodel",
+      ...config.searchPath !== undefined ? { search_path: config.searchPath } : {}
+    },
+    onnotice(notice) {
+      state.notices.push(notice);
+    }
+  };
+}
 function open2(config) {
   const max = config.max ?? 10;
   const acquireMs = config.timeouts?.acquire;
@@ -20,47 +132,50 @@ function open2(config) {
   let closed = false;
   const isClosed = () => closed;
   const named = config.prepared === "named";
-  const sql = postgres(config.url, {
+  const plain = config.ssl === undefined;
+  const sockets = new PoolSockets;
+  const sql = postgres(config.url, driverOptions(config, {
     max,
-    prepare: named,
-    idle_timeout: 30,
-    connect_timeout: 5,
-    types: WIRE_TYPES,
-    ...config.ssl !== undefined ? { ssl: config.ssl } : {},
-    connection: {
-      application_name: "okmodel",
-      ...config.searchPath !== undefined ? { search_path: config.searchPath } : {}
-    },
-    onnotice(notice) {
-      notices.push(notice);
-    }
-  });
+    named,
+    plain,
+    notices,
+    sockets
+  }));
   const root = new PgSession(sql, counters, "pool", poolInflight, isClosed, undefined, notices, named);
   const held = { sql, acquireMs, counters, isClosed, notices, named, poolInflight };
   return {
     capabilities: POSTGRESJS_CAPABILITIES,
     execute(text, params, options) {
-      return runCall(closed, options, (watch) => root.query(text, params, watch));
+      return sockets.occupy(() => runCall(closed, options, (watch) => root.query(text, params, watch)));
     },
     async batch(statements, options) {
-      const { checkout } = await import("./tb4ze1tr.js");
-      const connection = await checkout(held);
-      try {
-        return await connection.batch(statements, options);
-      } finally {
-        await connection.release();
-      }
+      return sockets.occupy(async () => {
+        const { checkout } = await import("./xqbhg6cn.js");
+        const connection = await checkout(held);
+        try {
+          return await connection.batch(statements, options);
+        } finally {
+          await connection.release();
+        }
+      });
     },
-    reserve: () => import("./tb4ze1tr.js").then((mod) => mod.checkout(held)),
-    describe: (text, params) => import("./tb4ze1tr.js").then((mod) => mod.describe(sql, text, params)),
+    reserve() {
+      return sockets.hold(async () => {
+        const mod = await import("./xqbhg6cn.js");
+        return mod.checkout(held);
+      });
+    },
+    describe: (text, params) => sockets.occupy(() => import("./xqbhg6cn.js").then((mod) => mod.describe(sql, text, params))),
     stream(text, params) {
-      return loadStream(sql, text, params);
+      return sockets.stream(() => loadStream(sql, text, params));
     },
-    async listen(channel, onNotify) {
-      const listening = await sql.listen(channel, onNotify);
-      return async () => {
-        await listening.unlisten();
-      };
+    listen(channel, onNotify) {
+      return sockets.listen(async () => {
+        const listening = await sql.listen(channel, onNotify);
+        return async () => {
+          await listening.unlisten();
+        };
+      });
     },
     cancel() {
       for (const pending of poolInflight)
@@ -179,7 +294,7 @@ class PgSession {
   }
 }
 async function* loadStream(sql, text, params) {
-  const { stream } = await import("./tb4ze1tr.js");
+  const { stream } = await import("./xqbhg6cn.js");
   yield* stream(sql, text, params);
 }
 function send(sql, text, params, named) {

package/dist/shared/{px90pf9p.js → hadrfb9h.js}

@@ -15,7 +15,7 @@ import {
   list,
   isRecord,
   fail
-} from "./f5thc1s0.js";
+} from "./rgs0st28.js";
 import {
   throwNamed2
 } from "./ycwz42az.js";
@@ -304,10 +304,12 @@ function parseInclude(schema, name, relation, value, all) {
 }
 function anchored(table, columns) {
   const pk = table.model.primary[0];
-  const selected = pk === undefined ? -1 : columns.findIndex((column) => column.field === pk);
+  if (pk === undefined)
+    return { presence: undefined, anchor: 0 };
+  const selected = columns.findIndex((column) => column.field === pk);
   if (selected >= 0)
     return { presence: undefined, anchor: selected };
-  return { presence: pk === undefined ? undefined : table.columns.get(pk), anchor: columns.length };
+  return { presence: table.columns.get(pk), anchor: columns.length };
 }
 function childIndex(schema, relation) {
   const child = indexes(schema).get(relation.table);

package/dist/shared/{4j72449d.js → jjb7yht9.js}

@@ -4,7 +4,7 @@ import {
 } from "./y9m15dfv.js";
 import {
   parsePlan
-} from "./kynx7vbm.js";
+} from "./05w44d8g.js";
 import {
   OkmError2
 } from "./ycwz42az.js";

package/dist/shared/{vkm3q4x1.js → kprcwaha.js}

@@ -2,7 +2,7 @@ import"./y9m15dfv.js";
 import {
   listTargets,
   loadConfig
-} from "./kynx7vbm.js";
+} from "./05w44d8g.js";
 
 // src/tooling/migrate/dev.ts
 import { mkdirSync } from "node:fs";

package/dist/shared/{g2v6gnc8.js → m3ypagh5.js}

@@ -1,12 +1,12 @@
 import {
   open2
-} from "./7ck0dtry.js";
+} from "./dkn3y60a.js";
 import {
   catalogHash2
 } from "./y9m15dfv.js";
 import {
   loadMigrations
-} from "./4j72449d.js";
+} from "./jjb7yht9.js";
 import {
   quoteIdent,
   planMigration,
@@ -15,7 +15,7 @@ import {
   selectTarget,
   projectHead,
   loadConfig
-} from "./kynx7vbm.js";
+} from "./05w44d8g.js";
 import {
   OkmError2
 } from "./ycwz42az.js";

package/dist/shared/{f5thc1s0.js → rgs0st28.js}

@@ -711,6 +711,7 @@ function createClient(schema, pool, options) {
   for (const name of Object.keys(schema.model)) {
     tables[name] = tableApi(session, name);
   }
+  let closing;
   const client = {
     ...tables,
     table(name) {
@@ -726,12 +727,27 @@ function createClient(schema, pool, options) {
       }
     },
     close() {
-      return options.ownsPool ? pool.close() : Promise.resolve();
+      if (!options.ownsPool)
+        return Promise.resolve();
+      closing ??= pool.close();
+      return closing;
     },
     connected
   };
+  attachAsyncDispose(client, () => client.close());
   return client;
 }
+function attachAsyncDispose(client, close) {
+  const symbol = Symbol.asyncDispose;
+  if (typeof symbol !== "symbol")
+    return;
+  Object.defineProperty(client, symbol, {
+    configurable: true,
+    enumerable: false,
+    writable: true,
+    value: () => close()
+  });
+}
 function tableApi(session, table) {
   return {
     find(options = {}) {
@@ -759,7 +775,7 @@ function tableApi(session, table) {
 }
 var writers;
 function loadWrite() {
-  writers ??= import("./ckb1p0a4.js");
+  writers ??= import("./x5x59srr.js");
   return writers;
 }
 function writeHandle(session, op, table, input, options, mods) {
@@ -834,7 +850,7 @@ function start(session, op, table, options, mods) {
     const { plan, params } = await prepare();
     try {
       const result = await session.pool.execute(plan.text, params, callOptions(mods));
-      const value = plan.outputs.includes.length === 0 ? decodeResult(plan, result.rows, table) : (await import("./px90pf9p.js")).decodeIncluded(plan, result.rows, table);
+      const value = plan.outputs.includes.length === 0 ? decodeResult(plan, result.rows, table) : (await import("./hadrfb9h.js")).decodeIncluded(plan, result.rows, table);
       if (mods.required === true && value === null) {
         throw new OkmError2("not_found", `one() on ${table} matched no row.`, withHttp(session.http, { kind: "not_found", table }));
       }
@@ -909,7 +925,7 @@ async function* streamRows(session, call, prepare) {
     })));
   }
   const { plan, params } = await prepare();
-  const decode = plan.outputs.includes.length === 0 ? decodeResult : (await import("./px90pf9p.js")).decodeIncluded;
+  const decode = plan.outputs.includes.length === 0 ? decodeResult : (await import("./hadrfb9h.js")).decodeIncluded;
   for await (const chunk of session.pool.stream(plan.text, params)) {
     const decoded = decode(plan, chunk, call.table);
     if (!Array.isArray(decoded))
@@ -1002,7 +1018,7 @@ var includeHooks;
 function hooksFor(call) {
   if (call.include === undefined)
     return Promise.resolve(undefined);
-  includeHooks ??= import("./px90pf9p.js").then((mod) => mod.includeHooks);
+  includeHooks ??= import("./hadrfb9h.js").then((mod) => mod.includeHooks);
   return includeHooks;
 }
 function bindNow(schema, call) {

package/dist/shared/{ckb1p0a4.js → x5x59srr.js}

@@ -8,7 +8,7 @@ import {
   quote,
   isRecord,
   fail
-} from "./f5thc1s0.js";
+} from "./rgs0st28.js";
 import {
   isOperator,
   operatorName,
@@ -78,7 +78,7 @@ async function planInsert(table, input, options, mods) {
       keyFields: undefined
     };
   }
-  const conflictMod = options.onConflict === undefined || options.onConflict === "error" ? undefined : await import("./79ggp945.js");
+  const conflictMod = options.onConflict === undefined || options.onConflict === "error" ? undefined : await import("./yd1kzwn2.js");
   const conflict = conflictMod?.readConflict(table, options.onConflict);
   const chunks = chunkRows(rows.map((row) => cellsFor(table, columns, row)));
   const statements = [];

package/dist/shared/{tb4ze1tr.js → xqbhg6cn.js}

@@ -1,6 +1,6 @@
 import {
   PgSession
-} from "./7ck0dtry.js";
+} from "./dkn3y60a.js";
 import {
   driverErrors,
   rejectClosed,

package/dist/shared/{79ggp945.js → yd1kzwn2.js}

@@ -4,7 +4,7 @@ import {
   list,
   isRecord,
   fail
-} from "./f5thc1s0.js";
+} from "./rgs0st28.js";
 import {
   throwNamed2
 } from "./ycwz42az.js";

package/dist/tooling/cli.js

@@ -5,7 +5,7 @@ import {
   generateProject,
   planProject,
   checkProject
-} from "../shared/kynx7vbm.js";
+} from "../shared/05w44d8g.js";
 import {
   OkmError2
 } from "../shared/ycwz42az.js";
@@ -41,12 +41,12 @@ async function run(argv, io) {
     return;
   }
   if (command === "dev") {
-    const { devProject } = await import("../shared/vkm3q4x1.js");
+    const { devProject } = await import("../shared/kprcwaha.js");
     stdout(await devProject(cwd));
     return;
   }
   if (command === "push") {
-    const { pushProject } = await import("../shared/g2v6gnc8.js");
+    const { pushProject } = await import("../shared/m3ypagh5.js");
     stdout(await pushProject(cwd, invoke(splitFlags(rest))));
     return;
   }
@@ -61,12 +61,12 @@ async function run(argv, io) {
       return;
     }
     if (sub === "apply") {
-      const { applyProject } = await import("../shared/g2v6gnc8.js");
+      const { applyProject } = await import("../shared/m3ypagh5.js");
       stdout(await applyProject(cwd, invoke(parsed)));
       return;
     }
     if (sub === "status") {
-      const { statusProject } = await import("../shared/ax16zpvm.js");
+      const { statusProject } = await import("../shared/523ft3e8.js");
       stdout(await statusProject(cwd, invoke(parsed)));
       return;
     }

package/package.json

@@ -1,7 +1,18 @@
 {
   "name": "okmodel",
-  "version": "0.1.0",
-  "description": "Catalog-first TypeScript ORM: typed queries, safe migrations and replica-aware routing. PostgreSQL first, zero runtime dependencies.",
+  "version": "0.1.1",
+  "description": "okmodel is a catalog-first TypeScript ORM, PostgreSQL first. Other SQL databases are the direction. Version 0.1 supports PostgreSQL only. The schema is the single source. Migrations and queries come from it.",
+  "keywords": [
+    "migrations",
+    "orm",
+    "postgres",
+    "postgresql",
+    "typescript"
+  ],
+  "homepage": "https://github.com/omqkhafi/okmodel",
+  "bugs": {
+    "url": "https://github.com/omqkhafi/okmodel/issues"
+  },
   "license": "Apache-2.0",
   "author": "Omq Khafi",
   "repository": {
@@ -60,13 +71,17 @@
     "layers-check": "bun ./scripts/layers-check.ts",
     "core-purity": "bun ./scripts/core-purity.ts",
     "docs:check": "bun ./scripts/docs-check.ts",
+    "readme:check": "bun ./scripts/readme-check.ts",
     "compiler-api": "bun ./scripts/compiler-api.ts",
     "publint": "publint run . --strict --pack bun",
     "attw": "bun ./scripts/attw.ts",
     "size": "bun ./scripts/size.ts",
     "bundle-purity": "bun ./scripts/bundle-purity.ts",
     "test": "bun test",
-    "check": "bun run format:check && bun run lint && bun run typecheck && bun run editor-check && bun run type-cost && bun run layers-check && bun run core-purity && bun run docs:check && bun run compiler-api && bun run bundle-purity && bun run build && bun test && bun run publint && bun run attw && bun run size",
+    "test:postgres": "bun ./scripts/postgres-suite.ts",
+    "test:tarball": "bun ./scripts/tarball-smoke.ts",
+    "verify": "bun ./scripts/verify.ts",
+    "check": "bun run format:check && bun run lint && bun run typecheck && bun run editor-check && bun run type-cost && bun run layers-check && bun run core-purity && bun run docs:check && bun run readme:check && bun run compiler-api && bun run bundle-purity && bun run build && bun test && bun run publint && bun run attw && bun run size",
     "bump": "bun ./scripts/bump-version.ts",
     "release-check": "bun ./scripts/release-check.ts",
     "db:up": "bun ./packages/harness/src/docker-cli.ts up",