@isaijs/core 0.1.6 → 0.1.9

package/dist/adapters/storage/r2/index.d.ts

@@ -9,6 +9,7 @@ export interface R2Binding {
 interface R2PutOptions {
   readonly httpMetadata?: {
     readonly contentType?: string;
+    readonly cacheControl?: string;
   };
 }
 interface R2ObjectBodyLike {
@@ -18,6 +19,8 @@ interface R2ObjectBodyLike {
     readonly contentType?: string;
   };
 }
+/** What every object is served with: its key never holds anything else. */
+export declare const CACHE_CONTROL = "public, max-age=31536000, immutable";
 export interface R2Options {
   /** Where the bucket serves its files (`https://media.example.com`), to make it a public storage. */
   readonly publicUrl?: string;

package/dist/adapters/storage/r2/index.js

@@ -4,14 +4,25 @@ import { a as publicUrlOf, n as bytesOf, r as checkedStream } from "../../../sto
 * `r2`: file storage on Cloudflare R2, by binding (no S3 keys), streamed through the Worker. With a
 * `publicUrl` (the bucket's custom domain, or its r2.dev URL) it's a public storage, and the bucket
 * serves its files; without one it's private, and the app serves them through signed links.
+*
+* Every object is stored with `Cache-Control: public, max-age=31536000, immutable`: isai never
+* writes a key twice (a file's key is its unguessable id), so browsers and Cloudflare's cache can
+* keep a file for good, and a page of photos doesn't read the bucket again for each viewer (R2
+* bills each read). The bucket's custom domain still needs a cache rule to cache files whose keys
+* have no extension.
 */
+/** What every object is served with: its key never holds anything else. */
+const CACHE_CONTROL = "public, max-age=31536000, immutable";
 function r2(binding, options = {}) {
 	const publicUrl = publicUrlOf(options.publicUrl);
 	return {
 		kind: "storage",
 		...publicUrl ? { publicUrl } : {},
 		put: async (key, body, { size, contentType }) => {
-			const httpMetadata = { contentType };
+			const httpMetadata = {
+				contentType,
+				cacheControl: CACHE_CONTROL
+			};
 			if (!(body instanceof ReadableStream)) {
 				await binding.put(key, await bytesOf(body, size), { httpMetadata });
 				return;
@@ -32,4 +43,4 @@ function r2(binding, options = {}) {
 	};
 }
 //#endregion
-export { r2 };
+export { CACHE_CONTROL, r2 };

package/dist/auth/index.d.ts

@@ -1,3 +1,3 @@
-import { r as AuthTablesOptions } from "../data-layer-43pme0Gy.js";
-import { A as Permissions, F as Policy, I as Rules, L as StandardAction, M as Bound, N as DefinePolicy, P as Perms, a as OAuthMethod, c as Roles, i as Methods, j as AnyPolicy, l as SignInMethod, n as AuthConfig, o as Provider, r as AuthDefinition, s as RoleDefinition, t as Auth, u as createAuth } from "../index-a7ElyL3B.js";
+import { r as AuthTablesOptions } from "../data-layer-nvm_ivGQ.js";
+import { B as Rules, F as AnyPolicy, I as Bound, L as DefinePolicy, P as Permissions, R as Perms, V as StandardAction, a as OAuthMethod, c as Roles, i as Methods, l as SignInMethod, n as AuthConfig, o as Provider, r as AuthDefinition, s as RoleDefinition, t as Auth, u as createAuth, z as Policy } from "../index-Bb9Px6SR.js";
 export { type AnyPolicy, Auth, type AuthConfig, type AuthDefinition, type AuthTablesOptions, type Bound, type DefinePolicy, type Methods, type OAuthMethod, type Permissions, type Perms, Policy, type Provider, type RoleDefinition, type Roles, type Rules, type SignInMethod, type StandardAction, createAuth };

package/dist/auth/index.js

@@ -1,3 +1,3 @@
-import { t as Policy } from "../policies-KsqmlX67.js";
-import { a as createAuth, t as Auth } from "../create-auth-BFKvQVOG.js";
+import { t as Policy } from "../policies-C_oiSgmY.js";
+import { a as createAuth, t as Auth } from "../create-auth-BCvMwlVD.js";
 export { Auth, Policy, createAuth };

package/dist/cli/index.js

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
-import { V as toKind, z as object } from "../validation-Cppmd0RV.js";
-import { F as dialectFor, m as emptySnapshot, r as sync, t as migrate, y as MigrationError } from "../migrator-B25prc9n.js";
-import { a as lookupsOf, i as filterableOf, n as isRequired, t as Resource, u as Route } from "../resource-BQK7bkPQ.js";
-import { o as fieldOf, p as sensitivity, t as Model } from "../model-Dc3HunKb.js";
+import { U as toKind, V as object } from "../validation-C3MCRBQO.js";
+import { I as dialectFor, h as snapshotOf, m as emptySnapshot, r as sync, t as migrate, y as MigrationError } from "../migrator-vvvKa0Vk.js";
+import { a as lookupsOf, i as filterableOf, n as isRequired, t as Resource, u as Route } from "../resource-DCg6LvMH.js";
+import { o as fieldOf, p as sensitivity, r as columnName, t as Model } from "../model-6pJBqqGd.js";
 import { t as kebabCase } from "../case-DpXlJCL9.js";
-import { i as makeMigrations, n as checkSteps, t as checkMigrations } from "../make-ByA-84h8.js";
+import { i as makeMigrations, n as checkSteps, t as checkMigrations } from "../make-D6_caNkv.js";
 import { d1 } from "../adapters/database/d1/index.js";
 import { spawn } from "node:child_process";
 import { parseArgs } from "node:util";
@@ -87,8 +87,22 @@ function generateClient(source) {
 	for (const { name, route } of [...source.routes].sort(byName)) {
 		const output = outputs.routes[name] ?? "unknown";
 		const args = routeArgs(route);
-		members.push(`  ${name}(${args}): Promise<${output === "undefined" ? "void" : output}>`);
-		table.push(`  ${name}: { route: [${JSON.stringify(route.method)}, ${JSON.stringify(route.path)}] },`);
+		const returns = `Promise<${output === "undefined" ? "void" : output}>`;
+		const files = route.input === "own" ? [] : Object.entries(route.input).filter(([, shape]) => toKind(shape).spec.file);
+		const uploads = files.map(([key]) => key);
+		const images = files.filter(([, shape]) => toKind(shape).spec.file?.image).map(([key]) => key);
+		if (uploads.length === 0) members.push(`  ${name}(${args}): ${returns}`);
+		else {
+			used.add("FileJSON");
+			const fields = uploads.map((key) => JSON.stringify(key)).join(" | ");
+			members.push(`  ${name}: {\n    (${args}): ${returns}\n    upload(field: ${fields}, file: Blob): Promise<FileJSON>\n  }`);
+		}
+		const endpoint = [
+			`route: [${JSON.stringify(route.method)}, ${JSON.stringify(route.path)}]`,
+			...uploads.length > 0 ? [`uploads: ${JSON.stringify(uploads)}`] : [],
+			...images.length > 0 ? [`images: ${JSON.stringify(images)}`] : []
+		];
+		table.push(`  ${name}: { ${endpoint.join(", ")} },`);
 	}
 	const body = [
 		...types,
@@ -550,7 +564,8 @@ const CLIENT_FILE = ".isai/client.ts";
 function appModules(root) {
 	return globSync("apps/**/*.ts", { cwd: root }).filter((file) => !/\.(test|d)\.ts$/.test(file)).sort().map((file) => join(root, file));
 }
-async function generate$1(project) {
+/** The app modules' resources and routes, loaded as the app loads them, and which file has which. */
+async function appExports(project) {
 	const resources = [];
 	const routes = [];
 	const modules = [];
@@ -581,6 +596,14 @@ async function generate$1(project) {
 		}
 		if (found.routes.length + found.resources.length > 0) modules.push(found);
 	}
+	return {
+		resources,
+		routes,
+		modules
+	};
+}
+async function generate$1(project) {
+	const { resources, routes, modules } = await appExports(project);
 	const user = (await loadModels(project)).find((found) => found.model.spec.name === "User")?.model;
 	return {
 		text: generateClient({
@@ -663,6 +686,42 @@ function watchClient(root, regenerate, settleMs = 200) {
 		watcher.close();
 	};
 }
+//#endregion
+//#region src/cli/indexes.ts
+/**
+* `isai check`'s warning about lists without an index: a resource that sorts by a field no index
+* leads with makes the database read the whole table, and sort it, for every page of the list
+* (and for every refresh of a screen that keeps it open). A warning, never a failure: a small
+* table never needs one, and only the app knows which tables grow. The fix is on the model:
+* `.index(...)` (`db/schema/model.ts`).
+*/
+/** One line per resource field sorted without an index, naming the `.index()` to add. */
+function unindexedSorts(resources, models) {
+	const snapshots = /* @__PURE__ */ new Map();
+	const snapshotFor = (database) => {
+		let snapshot = snapshots.get(database);
+		if (!snapshot) {
+			snapshot = snapshotOf(models.filter((m) => m.database === database).map((m) => m.model));
+			snapshots.set(database, snapshot);
+		}
+		return snapshot;
+	};
+	const warnings = [];
+	for (const { name, resource } of resources) {
+		const spec = resource.model.spec;
+		const found = models.find((m) => m.model.spec.name === spec.name);
+		if (!found) continue;
+		const indexes = snapshotFor(found.database).tables[spec.table]?.indexes ?? [];
+		for (const field of resource.sortable) {
+			const fieldSpec = spec.fields[field];
+			if (!fieldSpec || fieldSpec.computed) continue;
+			const column = columnName(field, fieldSpec);
+			if (column === "id" || indexes.some((index) => index.columns[0] === column)) continue;
+			warnings.push(`${name} sorts by ${spec.name}.${field}, which no index leads with: each page reads the whole table. Add .index("${field}") to ${spec.name}${found.file ? ` (db/schema/${found.file}.ts)` : ""}`);
+		}
+	}
+	return warnings;
+}
 const PLATFORM = "platform";
 /** One history per database: `migrations/<database>/` (`migrations/tenant/`, `migrations/main/`). */
 const migrationsDir = (root, database) => join(root, "migrations", database);
@@ -1109,11 +1168,13 @@ const commands = {
 		await writeClient(project, log);
 		return 0;
 	},
-	/** Fails when something generated is out of date with the app (CI). */
+	/** Fails when something generated is out of date with the app (CI); warns about lists without an index. */
 	async check(project) {
 		await checkClient(project);
 		checkDeployable(project.root);
-		log("No problems");
+		const warnings = await indexWarnings(project);
+		for (const warning of warnings) log(`⚠ ${warning}`);
+		log(warnings.length === 0 ? "No problems" : `No problems; ${warnings.length} warning${warnings.length === 1 ? "" : "s"}`);
 		return 0;
 	},
 	/**
@@ -1140,6 +1201,7 @@ const commands = {
 		await writeClient(project, log).catch((error) => {
 			log(`\n⚠ The typed client wasn't written: ${error instanceof Error ? error.message : error}\n`);
 		});
+		for (const warning of await indexWarnings(project).catch(() => [])) log(`⚠ ${warning}`);
 		const token = crypto.randomUUID();
 		const served = wranglerDev(project.root, [
 			...wrangler,
@@ -1160,6 +1222,11 @@ const commands = {
 		return served;
 	}
 };
+/** Resources sorted by a field no index leads with (`./indexes`). */
+async function indexWarnings(project) {
+	const { resources } = await appExports(project);
+	return unindexedSorts(resources, await loadModels(project));
+}
 /**
 * `isai client` in a new process: this one has the app's modules cached as they were on start, and
 * ESM can't unload them. A failure is printed by the child; the server keeps running.
@@ -1196,7 +1263,8 @@ const usage = `usage: isai <command>
   makemigrations [--check]   write migration steps for model changes (--check: fail if one is missing)
   migrate [--remote]         apply pending migrations to the local databases (--remote: the deployed ones)
   client                     write .isai/client.ts, the typed client for the app's frontends
-  check                      fail if .isai/client.ts is stale, or a D1 database has no database_id
+  check                      fail if .isai/client.ts is stale, or a D1 database has no database_id;
+                             warn when a resource sorts by a field no index leads with
   dev [--seed <name>] [wrangler args]
                              migrate, then run wrangler dev, rewriting the typed client on each change
                              (--seed: fill the local databases from a seed)`;

package/dist/client/index.d.ts

@@ -165,6 +165,10 @@ interface ResourceEndpoint {
 /** A route in the endpoint table. */
 interface RouteEndpoint {
   readonly route: readonly [Method, string];
+  /** Its file inputs: `upload(field, file)` sends a file to name by id in its input. */
+  readonly uploads?: readonly string[];
+  /** Those of them that are images: resized in the browser before they're sent. */
+  readonly images?: readonly string[];
 }
 type Endpoints = Readonly<Record<string, ResourceEndpoint | RouteEndpoint>>;
 type FetchLike = (input: Request | string | URL, init?: RequestInit) => Promise<Response>;

package/dist/client/index.js

@@ -159,6 +159,7 @@ async function encoded(canvas, name, clear) {
 *               · <custom action>(key, input?) · upload(field, file)  (an image is resized first)
 *               (a singleton's calls take no key)
 *   routes      api.<name>(args)                           (path params and input in one object)
+*               · api.<name>.upload(field, file)            (a route with file inputs)
 *   auth        api.auth.me() · signIn() · signOut() · users · invites
 *
 * Writes survive a dropping connection. Every write (any call but a GET) carries an
@@ -237,7 +238,7 @@ function createClient(endpoints, options = {}) {
 	};
 	for (const [name, endpoint] of Object.entries(endpoints)) {
 		if (Object.hasOwn(api, name)) throw new TypeError(`isai: the client's ${name} is taken`);
-		api[name] = "route" in endpoint ? routeCall(call, endpoint) : resourceCalls(call, endpoint);
+		api[name] = "route" in endpoint ? routeCall(call, endpoint, name) : resourceCalls(call, endpoint);
 	}
 	return api;
 }
@@ -350,18 +351,20 @@ function resourceCalls(call, endpoint) {
 		default: calls[action] = actionCall(call, keyed, action);
 	}
 	for (const action of endpoint.custom ?? []) calls[action] = actionCall(call, keyed, action);
-	if (endpoint.uploads?.length) {
-		const fields = new Set(endpoint.uploads);
-		const images = new Set(endpoint.images);
-		calls.upload = (field, file) => {
-			if (!fields.has(field)) throw new TypeError(`isai: ${base} takes no upload for ${field}`);
-			const path = `/uploads${base}/${kebabCase(field)}`;
-			if (!images.has(field)) return call("POST", path, { body: file });
-			return uploadImage(call, path, file);
-		};
-	}
+	if (endpoint.uploads?.length) calls.upload = uploadCall(call, base, endpoint);
 	return calls;
 }
+/** `upload(field, file)` to `/uploads<base>/<field>`: an image field's file is resized first. */
+function uploadCall(call, base, endpoint) {
+	const fields = new Set(endpoint.uploads);
+	const images = new Set(endpoint.images);
+	return (field, file) => {
+		if (!fields.has(field)) throw new TypeError(`isai: ${base} takes no upload for ${field}`);
+		const path = `/uploads${base}/${kebabCase(field)}`;
+		if (!images.has(field)) return call("POST", path, { body: file });
+		return uploadImage(call, path, file);
+	};
+}
 /** An image, resized: the full one, then its smaller copy with `X-Size-Of`; the answer is the image. */
 async function uploadImage(call, path, file) {
 	const sizes = await resized(file, file.name ?? "image");
@@ -377,9 +380,9 @@ function actionCall(call, keyed, action) {
 	return keyed((path, input) => call("POST", `${path}/${kebabCase(action)}`, input === void 0 ? {} : { body: input }));
 }
 /** A route: `:params` filled from the argument, the rest its input (the body, or the query string on GET / DELETE). */
-function routeCall(call, endpoint) {
+function routeCall(call, endpoint, name) {
 	const [method, template] = endpoint.route;
-	return (args = {}) => {
+	const run = (args = {}) => {
 		const input = { ...args };
 		const path = template.replace(/:([A-Za-z0-9_]+)/g, (_, name) => {
 			const value = input[name];
@@ -392,6 +395,8 @@ function routeCall(call, endpoint) {
 		for (const [key, value] of Object.entries(input)) if (value !== void 0) query.set(key, typeof value === "string" ? value : JSON.stringify(value));
 		return call(method, path, { query });
 	};
+	if (endpoint.uploads?.length) return Object.assign(run, { upload: uploadCall(call, `/${kebabCase(name)}`, endpoint) });
+	return run;
 }
 /** A value in a list's query string: text as it is, a list comma-separated. */
 function queryValue(value) {

package/dist/{create-auth-BFKvQVOG.js → create-auth-BCvMwlVD.js}

@@ -1,6 +1,6 @@
-import { I as fromBase64url } from "./model-Dc3HunKb.js";
-import { n as PROVIDERS } from "./tables-DgSwge7s.js";
-import { a as byRole, c as tenant, i as anyone, l as user, n as PolicyRegistry, o as owner, s as readsTenant } from "./policies-KsqmlX67.js";
+import { I as fromBase64url } from "./model-6pJBqqGd.js";
+import { n as PROVIDERS } from "./tables-DjW96Ubl.js";
+import { a as byRole, c as tenant, i as anyone, l as user, n as PolicyRegistry, o as owner, s as readsTenant } from "./policies-C_oiSgmY.js";
 //#region src/auth/create-auth.ts
 const methods = { oauth: (provider, options) => ({
 	kind: "oauth",

package/dist/{data-layer-C5oJZ8V1.js → data-layer-BOVkYESH.js}

@@ -1,7 +1,7 @@
-import { F as quantity, k as datetime, m as host, r as isPhoneRegion } from "./validation-Cppmd0RV.js";
-import "./migrator-B25prc9n.js";
-import { D as now, E as not, S as any, T as count, a as defineModel, c as rowOf, d as fieldKinds, u as field, x as all, y as Relation } from "./model-Dc3HunKb.js";
-import { a as TableSet, i as platformAuthDefinitions, o as defineBuiltins, r as authTables } from "./tables-DgSwge7s.js";
+import { L as quantity, g as host, j as datetime, r as isPhoneRegion } from "./validation-C3MCRBQO.js";
+import "./migrator-vvvKa0Vk.js";
+import { D as now, E as not, S as any, T as count, a as defineModel, c as rowOf, d as fieldKinds, u as field, x as all, y as Relation } from "./model-6pJBqqGd.js";
+import { a as TableSet, i as platformAuthDefinitions, o as defineBuiltins, r as authTables } from "./tables-DjW96Ubl.js";
 import { n as seed } from "./seed-BObmdKdP.js";
 //#region src/db/fields/slot.ts
 var Slot = class {
@@ -77,6 +77,8 @@ function uploadTables(f, options) {
 			fileId: f.line().unique(),
 			/** The file as stored, written into the field that attaches it. */
 			file: f.file(),
+			/** Bytes stored for it, its smaller copies' too: what a cap counts as pending. */
+			size: f.quantity().default(0),
 			/** Where it may be attached: `<resource or route>/<field>` (`manage-products/images`). */
 			target: f.line(),
 			/** Who uploaded it (a user's id); empty for an anonymous upload. */
@@ -173,8 +175,8 @@ var ModelRegistry = class {
 /**
 * Traits: behaviour a model takes whole, written before its fields (`model(name, ...traits,
 * fields)`), Laravel's traits typed. A trait adds fields (so the model's own fields already see
-* them; declaring one of them again is an error), computed fields, and a name the framework reads
-* (`singleton`). Always written `traits.x()`, never imported bare: a bare `publishable()` reads like
+* them; declaring one of them again is an error), computed fields, the indexes its behaviour reads
+* by, and a name the framework reads (`singleton`). Always written `traits.x()`, never imported bare: a bare `publishable()` reads like
 * an action.
 */
 var Trait = class {
@@ -188,10 +190,11 @@ var Trait = class {
 *
 * - `ordered({ within })`: a `position` the database keeps: a new row goes last in its group (the
 *   rows sharing `within`, or the whole table), reads are in position order unless they name
-*   their own, and `db.reorder(Model, ids)` sets a group's order.
+*   their own, and `db.reorder(Model, ids)` sets a group's order. Indexed by its group, then
+*   `position` (which also serves the group's ref).
 * - `singleton()`: one row, with the id `"singleton"`; read it with `findMany(Model).first()`.
 * - `publishable()`: `publishedAt` (empty: a draft; in the future: scheduled) and `published`,
-*   true once it has passed.
+*   true once it has passed. Indexed by `publishedAt`, for lists of the newest.
 */
 function builtinTraits() {
 	return {
@@ -201,7 +204,8 @@ function builtinTraits() {
 				by: "position",
 				within: options.within
 			} }) },
-			computed: {}
+			computed: {},
+			indexes: [options.within === void 0 ? ["position"] : [options.within, "position"]]
 		}),
 		singleton: () => new Trait({
 			name: "singleton",
@@ -212,7 +216,8 @@ function builtinTraits() {
 			return new Trait({
 				name: "publishable",
 				fields: { publishedAt: field(datetime(), "datetime").optional() },
-				computed: { published: (row) => all(row.publishedAt.isNull().not(), row.publishedAt.lte(now)) }
+				computed: { published: (row) => all(row.publishedAt.isNull().not(), row.publishedAt.lte(now)) },
+				indexes: [["publishedAt"]]
 			});
 		}
 	};

package/dist/{data-layer-43pme0Gy.d.ts → data-layer-nvm_ivGQ.d.ts}

@@ -1,13 +1,15 @@
 import { a as DatabaseDriver, o as DialectName } from "./index-Ce5p2-EB.js";
 import { t as Issue } from "./issues-CKto95IW.js";
-import { M as IdInput, Y as StoredFile } from "./index-CYcklQ1l.js";
-import { $ as Expr, A as Dialect, G as Model, H as Columns, I as Clock, K as ModelSpec, M as RetiredSnapshot, N as SchemaSnapshot, U as ComputedFields, V as AnyModel, W as Fields, X as Condition, at as count, b as RowOf, dt as Kinds, et as Now, f as seed, ft as SchemaDefaults, ht as Field, i as Row, it as any, mt as AnyField, n as Patch, ot as not, p as Database, q as ModelRegistry, rt as all, yt as Slot } from "./types-BgOkJy5d.js";
+import { M as IdInput, Y as StoredFile } from "./index-CaR3hb0i.js";
+import { $ as Expr, A as Dialect, G as Model, H as Columns, I as Clock, K as ModelSpec, M as RetiredSnapshot, N as SchemaSnapshot, U as ComputedFields, V as AnyModel, W as Fields, X as Condition, at as count, b as RowOf, dt as Kinds, et as Now, f as seed, ft as SchemaDefaults, ht as Field, i as Row, it as any, mt as AnyField, n as Patch, ot as not, p as Database, q as ModelRegistry, rt as all, yt as Slot } from "./types-D5SIVeej.js";
 //#region src/db/schema/traits.d.ts
 type ComputedDefinitions = Record<string, (row: any) => Condition>;
 interface TraitSpec {
   readonly name: string;
   readonly fields: Fields;
   readonly computed: ComputedDefinitions;
+  /** Indexes the model gets, by field names: what the trait's own reads sort or group by. */
+  readonly indexes?: readonly (readonly string[])[];
 }
 declare class Trait<F extends Fields = Fields, C extends ComputedDefinitions = ComputedDefinitions> {
   readonly spec: TraitSpec;
@@ -741,6 +743,8 @@ declare function uploadTables(f: Kinds, options: UploadTablesOptions): TableSet<
       }>;
       /** The file as stored, written into the field that attaches it. */
       file: Field<StoredFile, StoredFile, false, false, {}>;
+      /** Bytes stored for it, its smaller copies' too: what a cap counts as pending. */
+      size: Field<number, number, false, true, {}>;
       /** Where it may be attached: `<resource or route>/<field>` (`manage-products/images`). */
       target: Field<string, string, false, false, {}>;
       /** Who uploaded it (a user's id); empty for an anonymous upload. */

package/dist/db/index.d.ts

@@ -1,4 +1,4 @@
 import { a as ValidationError } from "../issues-CKto95IW.js";
-import { $ as Expr, A as Dialect, B as newSecretKey, F as snapshotOf, G as Model, I as Clock, J as Models, K as ModelSpec, L as FixedClock, M as RetiredSnapshot, N as SchemaSnapshot, O as Write, P as emptySnapshot, R as fixedClock, V as AnyModel, X as Condition, Y as Column, _ as database, _t as Storage, a as Visible, at as count, bt as slot, c as Many, d as SeedContext, dt as Kinds, et as Now, ft as SchemaDefaults, g as Transaction, gt as FieldSpec, h as RawValue, ht as Field, i as Row, it as any, j as Rule, k as WriteListener, l as Overrides, lt as ConditionNode, m as DatabaseOptions, n as Patch, nt as Total, o as Make, ot as not, p as Database, pt as fieldKinds, r as Planned, rt as all, st as now, t as Insert, tt as Relation, u as Seed, v as OrderKey, vt as sensitivity, y as Query, yt as Slot, z as systemClock } from "../types-BgOkJy5d.js";
-import { A as MigrateOptions, B as NotFound, C as MigrationErrorCode, D as Cleanup, E as UnsafeMigration, F as DataStep, H as UniqueFailed, I as TODO, L as dataStep, M as migrate, N as migrateFresh, O as cleanupMigration, P as sync, R as CheckFailed, S as MigrationError, T as UnsafeChange, U as dialectFor, V as ReferenceFailed, W as sqlite, _ as Generated, b as manifest, c as acquireLock, d as setReleaseStatus, f as startRelease, g as makeMigrations, h as makeCleanup, j as Migration, k as Manifest, l as releaseLock, m as checkMigrations, n as row, o as Release, p as applyRules, s as ReleaseStatus, t as createDataLayer, u as rollback, v as generateMigration, w as SuspectedRename, x as structureStep, y as cleanupStep, z as DatabaseError } from "../data-layer-43pme0Gy.js";
+import { $ as Expr, A as Dialect, B as newSecretKey, F as snapshotOf, G as Model, I as Clock, J as Models, K as ModelSpec, L as FixedClock, M as RetiredSnapshot, N as SchemaSnapshot, O as Write, P as emptySnapshot, R as fixedClock, V as AnyModel, X as Condition, Y as Column, _ as database, _t as Storage, a as Visible, at as count, bt as slot, c as Many, d as SeedContext, dt as Kinds, et as Now, ft as SchemaDefaults, g as Transaction, gt as FieldSpec, h as RawValue, ht as Field, i as Row, it as any, j as Rule, k as WriteListener, l as Overrides, lt as ConditionNode, m as DatabaseOptions, n as Patch, nt as Total, o as Make, ot as not, p as Database, pt as fieldKinds, r as Planned, rt as all, st as now, t as Insert, tt as Relation, u as Seed, v as OrderKey, vt as sensitivity, y as Query, yt as Slot, z as systemClock } from "../types-D5SIVeej.js";
+import { A as MigrateOptions, B as NotFound, C as MigrationErrorCode, D as Cleanup, E as UnsafeMigration, F as DataStep, H as UniqueFailed, I as TODO, L as dataStep, M as migrate, N as migrateFresh, O as cleanupMigration, P as sync, R as CheckFailed, S as MigrationError, T as UnsafeChange, U as dialectFor, V as ReferenceFailed, W as sqlite, _ as Generated, b as manifest, c as acquireLock, d as setReleaseStatus, f as startRelease, g as makeMigrations, h as makeCleanup, j as Migration, k as Manifest, l as releaseLock, m as checkMigrations, n as row, o as Release, p as applyRules, s as ReleaseStatus, t as createDataLayer, u as rollback, v as generateMigration, w as SuspectedRename, x as structureStep, y as cleanupStep, z as DatabaseError } from "../data-layer-nvm_ivGQ.js";
 export { type AnyModel, CheckFailed, type Cleanup, type Clock, Column, Condition, type ConditionNode, type DataStep, Database, DatabaseError, type DatabaseOptions, type Dialect, Expr, Field, type FieldSpec, type FixedClock, type Generated, type Insert, type Kinds, type Make, type Manifest, type Many, type MigrateOptions, type Migration, MigrationError, type MigrationErrorCode, Model, type ModelSpec, type Models, NotFound, Now, type OrderKey, type Overrides, type Patch, type Planned, Query, type RawValue, ReferenceFailed, Relation, type Release, type ReleaseStatus, type RetiredSnapshot, type Row, type Rule, type SchemaDefaults, type SchemaSnapshot, Seed, type SeedContext, Slot, type Storage, type SuspectedRename, TODO, Total, Transaction, UniqueFailed, type UnsafeChange, UnsafeMigration, ValidationError, type Visible, type Write, type WriteListener, acquireLock, all, any, applyRules, checkMigrations, cleanupMigration, cleanupStep, count, createDataLayer, dataStep, database, dialectFor, emptySnapshot, fieldKinds, fixedClock, generateMigration, makeCleanup, makeMigrations, manifest, migrate, migrateFresh, newSecretKey, not, now, releaseLock, rollback, row, sensitivity, setReleaseStatus, slot, snapshotOf, sqlite, startRelease, structureStep, sync, systemClock };

package/dist/db/index.js

@@ -1,9 +1,9 @@
-import { G as ValidationError } from "../validation-Cppmd0RV.js";
-import { C as database, F as dialectFor, G as newSecretKey, H as fixedClock, I as sqlite, J as NotFound, K as CheckFailed, M as Query, U as systemClock, X as UniqueFailed, Y as ReferenceFailed, _ as TODO, b as Database, c as rollback, d as applyRules, g as UnsafeMigration, h as snapshotOf, i as acquireLock, l as setReleaseStatus, m as emptySnapshot, n as migrateFresh, p as generateMigration, q as DatabaseError, r as sync, s as releaseLock, t as migrate, u as startRelease, v as dataStep, x as Transaction, y as MigrationError } from "../migrator-B25prc9n.js";
-import { D as now, E as not, S as any, T as count, _ as Expr, b as Total, d as fieldKinds, f as Field, h as Condition, m as Column, p as sensitivity, t as Model, v as Now, x as all, y as Relation } from "../model-Dc3HunKb.js";
-import { i as slot, n as row, r as Slot, t as createDataLayer } from "../data-layer-C5oJZ8V1.js";
+import { q as ValidationError } from "../validation-C3MCRBQO.js";
+import { C as database, I as dialectFor, J as DatabaseError, K as newSecretKey, L as sqlite, M as Query, U as fixedClock, W as systemClock, X as ReferenceFailed, Y as NotFound, Z as UniqueFailed, _ as TODO, b as Database, c as rollback, d as applyRules, g as UnsafeMigration, h as snapshotOf, i as acquireLock, l as setReleaseStatus, m as emptySnapshot, n as migrateFresh, p as generateMigration, q as CheckFailed, r as sync, s as releaseLock, t as migrate, u as startRelease, v as dataStep, x as Transaction, y as MigrationError } from "../migrator-vvvKa0Vk.js";
+import { D as now, E as not, S as any, T as count, _ as Expr, b as Total, d as fieldKinds, f as Field, h as Condition, m as Column, p as sensitivity, t as Model, v as Now, x as all, y as Relation } from "../model-6pJBqqGd.js";
+import { i as slot, n as row, r as Slot, t as createDataLayer } from "../data-layer-BOVkYESH.js";
 import { t as Seed } from "../seed-BObmdKdP.js";
-import { a as cleanupMigration, i as makeMigrations, r as makeCleanup, t as checkMigrations } from "../make-ByA-84h8.js";
+import { a as cleanupMigration, i as makeMigrations, r as makeCleanup, t as checkMigrations } from "../make-D6_caNkv.js";
 //#region src/db/migrations/files.ts
 /** A structure step file: adds tables and columns. Applied once, never edited. */
 function structureStep(options) {