@chromav/sizzler 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Eddy Recio
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,169 @@
+# sizzler 🔥
+
+**Sensible defaults for Drizzle + SQLite. Now we're sizzling.**
+
+Stop bikeshedding IDs, timestamps, and foreign keys. Define your schema, seed your database, and get back to building.
+
+```typescript
+import { primaryKey, foreignKey, createdAt, updatedAt, table, text, enums } from "sizzler";
+
+const status = ["pending", "in_progress", "done"] as const;
+
+export const tasks = table("tasks", {
+  id: primaryKey(),                              // ULID — sortable, client-generatable
+  title: text("title").notNull(),
+  status: enums("status", status),               // type-safe, defaults to first value
+  assigneeId: foreignKey("assignee_id", users.id),
+  createdAt: createdAt(),                        // unixepoch() default
+  updatedAt: updatedAt(),
+});
+```
+
+Works with D1, Turso, libsql, better-sqlite3 — anywhere Drizzle's SQLite adapter runs.
+
+## What's in the box
+
+### 1. Schema factories
+
+Sensible defaults so you don't have to think about it:
+
+| Factory | What you get |
+|---------|--------------|
+| `primaryKey()` | Text ULID — sortable by time, generate client-side, no DB roundtrip |
+| `foreignKey(name, ref)` | Text FK to match ULID PKs (pass `"integer"` for numeric refs) |
+| `createdAt()` / `updatedAt()` | Timestamps with `unixepoch()` default |
+| `timestamp(name)` | Bare timestamp, no default |
+| `boolean(name)` | Integer 0/1 (SQLite has no boolean type) |
+| `enums(name, values)` | Type-safe text column, defaults to first value |
+| `jsonArray<T>(name)` | Typed JSON storage |
+| `timestampMs(name)` | Integer timestamp in milliseconds (for BetterAuth compatibility) |
+
+Every factory returns a standard Drizzle column builder. Chain `.notNull()`, `.unique()`, whatever — then use `drizzle-kit` like normal.
+
+### 2. Local dev helpers
+
+The `sizzler/node` entry point gets you connected and seeded fast:
+
+```typescript
+import { computeD1Filename, getLocalD1Path, createJSONSeeder, resetDatabase } from "sizzler/node";
+
+// Compute the exact filename miniflare uses for a D1 database
+const filename = computeD1Filename("3c9d1256-e9bd-4617-ad46-22315915a680");
+// => "feed28b9d46e13dcb8b4ff9ebe14a54b3b84fc08efd83b1de4251b30f50c9f10.sqlite"
+
+// Find your local D1 database (uses computeD1Filename internally)
+const dbPath = getLocalD1Path();
+
+// Load seed data with automatic transforms
+const seeder = createJSONSeeder({
+  baseDir: "./seeds",
+  transformers: commonTransformers.dateFields(["createdAt", "updatedAt"]),
+});
+const users = seeder.loadJSON("users.json");
+
+// Reset and reseed (requires explicit confirmation)
+await resetDatabase(db, schema, { confirm: true });
+```
+
+No more hunting for SQLite files in `.wrangler/`. No more reverse-engineering miniflare's hashed filenames. No more manual date parsing in seed scripts.
+
+### 3. Golden snapshots
+
+Also on `sizzler/node`: helpers for creating and restoring self-contained SQLite
+"golden" snapshots — the foundation of fast, reproducible E2E tests (build the DB
+once, restore the file per run instead of migrating + seeding every time).
+
+```typescript
+import { createSnapshot, restoreSnapshot } from "sizzler/node";
+
+// Create a golden snapshot from a live DB: checkpoints the WAL into the main
+// file (so the .sqlite is self-contained), copies it, and verifies it has data.
+createSnapshot(liveDbPath, "test-data/golden/test.sqlite", {
+  verify: { countQuery: "SELECT COUNT(*) as count FROM user", min: 1 },
+});
+
+// Restore it onto a target DB atomically (temp file + rename — no torn/missing
+// window), with a corruption guard and optional post-restore verification.
+restoreSnapshot("test-data/golden/test.sqlite", liveDbPath, {
+  minBytes: 100 * 1024,
+  verify: { countQuery: "SELECT COUNT(*) as count FROM user", min: 1 },
+});
+```
+
+Lower-level primitives are exported too: `checkpointDatabase`, `removeWalFiles`,
+`removeOldSnapshot`, `verifySnapshot`, and `countRows`. These require the optional
+`better-sqlite3` peer dependency (node-only — never imported in a Worker bundle),
+and pair with `computeD1Filename`/`parseWranglerConfig` to locate the miniflare D1
+file to snapshot or restore.
+
+> ⚠️ **Restore semantics:** `restoreSnapshot` creates a new inode at the target
+> path. Run it *before the server process opens the DB* (e.g. a `pretest` step),
+> not mid-session against a live server — a running worker's mmap won't see the
+> swapped file. (For mid-session resets, reset *within* the live DB connection
+> instead.)
+
+## Installation
+
+```bash
+npm install sizzler drizzle-orm
+```
+
+## The boilerplate it replaces
+
+<details>
+<summary>See before/after</summary>
+
+**Before:**
+
+```typescript
+import { sqliteTable, text, integer } from "drizzle-orm/sqlite-core";
+import { sql } from "drizzle-orm";
+import { ulid } from "ulid";
+
+export const tasks = sqliteTable("tasks", {
+  id: text("id").primaryKey().notNull().$defaultFn(() => ulid()),
+  title: text("title").notNull(),
+  status: text("status", { enum: ["pending", "in_progress", "done"] }).default("pending"),
+  assigneeId: text("assignee_id").references(() => users.id),
+  createdAt: integer("created_at", { mode: "timestamp" }).notNull().default(sql`(unixepoch())`),
+  updatedAt: integer("updated_at", { mode: "timestamp" }).notNull().default(sql`(unixepoch())`),
+});
+```
+
+**After:**
+
+```typescript
+import { primaryKey, foreignKey, createdAt, updatedAt, table, text, enums } from "sizzler";
+
+const status = ["pending", "in_progress", "done"] as const;
+
+export const tasks = table("tasks", {
+  id: primaryKey(),
+  title: text("title").notNull(),
+  status: enums("status", status),
+  assigneeId: foreignKey("assignee_id", users.id),
+  createdAt: createdAt(),
+  updatedAt: updatedAt(),
+});
+```
+
+</details>
+
+## Why ULIDs?
+
+The primary key choice is the most opinionated default. Here's the reasoning:
+
+- **Sortable** — First 10 chars encode a millisecond timestamp. `ORDER BY id` works like `ORDER BY created_at`.
+- **Client-generatable** — Know the ID before the insert hits the database. Essential for optimistic UI.
+- **No coordination** — Works across edge locations, replicas, offline-first apps.
+
+Integer autoincrement requires a roundtrip to learn the ID. ULIDs let client and server agree on the ID upfront.
+
+## Documentation
+
+- [API Reference](docs/api-reference.md) — Full signatures and examples for all factories
+- [Node.js Utilities](docs/node-utilities.md) — D1 path resolution, JSON seeding, database reset
+
+## License
+
+MIT

package/dist/columns/foreign-key.d.ts

@@ -0,0 +1,33 @@
+import type { SQLiteColumn, SQLiteIntegerBuilder, SQLiteTextBuilder, UpdateDeleteAction } from "drizzle-orm/sqlite-core";
+type ActionConfig = {
+    onUpdate?: UpdateDeleteAction;
+    onDelete?: UpdateDeleteAction;
+};
+/**
+ * Creates a foreign key column with configurable cascade actions.
+ *
+ * Defaults to `"text"` type to match sizzler's ULID-based `primaryKey()`.
+ * Use `"integer"` for auto-increment or numeric foreign keys.
+ *
+ * @param name - Column name
+ * @param col - Reference column from another table
+ * @param type - Column type: `"text"` (default) or `"integer"`
+ * @param actions - Optional cascade actions for onUpdate/onDelete
+ * @returns A column configured as a foreign key
+ *
+ * @example
+ * ```ts
+ * const posts = table("posts", {
+ *   id: primaryKey(),
+ *   // Text foreign key (default — matches ULID primary keys)
+ *   authorId: foreignKey("author_id", users.id),
+ *   // With cascade options
+ *   parentId: foreignKey("parent_id", posts.id, "text", { onDelete: "cascade" }),
+ *   // Integer foreign key (for numeric references)
+ *   legacyCategoryId: foreignKey("category_id", categories.id, "integer"),
+ * });
+ * ```
+ */
+export declare const foreignKey: <T extends "integer" | "text" = "text">(name: string, col: SQLiteColumn, type?: T, actions?: ActionConfig) => T extends "integer" ? SQLiteIntegerBuilder : SQLiteTextBuilder<[string, ...string[]]>;
+export {};
+//# sourceMappingURL=foreign-key.d.ts.map

package/dist/columns/foreign-key.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"foreign-key.d.ts","sourceRoot":"","sources":["../../src/columns/foreign-key.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,YAAY,EACZ,oBAAoB,EACpB,iBAAiB,EACjB,kBAAkB,EACnB,MAAM,yBAAyB,CAAC;AAGjC,KAAK,YAAY,GAAG;IAClB,QAAQ,CAAC,EAAE,kBAAkB,CAAC;IAC9B,QAAQ,CAAC,EAAE,kBAAkB,CAAC;CAC/B,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,eAAO,MAAM,UAAU,GAAI,CAAC,SAAS,SAAS,GAAG,MAAM,GAAG,MAAM,EAC9D,MAAM,MAAM,EACZ,KAAK,YAAY,EACjB,OAAM,CAAe,EACrB,UAAU,YAAY,KACrB,CAAC,SAAS,SAAS,GAAG,oBAAoB,GAAG,iBAAiB,CAAC,CAAC,MAAM,EAAE,GAAG,MAAM,EAAE,CAAC,CAKzC,CAAC"}

package/dist/columns/helpers.d.ts

@@ -0,0 +1,59 @@
+import { index as sqliteIndex, integer as sqliteInteger, real as sqliteReal, text as sqliteText } from "drizzle-orm/sqlite-core";
+type EnumValues = readonly [string, ...string[]];
+export declare const table: import("drizzle-orm/sqlite-core").SQLiteTableFn<undefined>;
+export declare const index: typeof sqliteIndex;
+export declare const integer: typeof sqliteInteger;
+export declare const real: typeof sqliteReal;
+export declare const text: typeof sqliteText;
+/**
+ * Creates a boolean column stored as integer (0/1).
+ *
+ * @param name - Column name
+ * @returns An integer column in boolean mode
+ *
+ * @example
+ * ```ts
+ * const users = table("users", {
+ *   isActive: boolean("is_active"),
+ * });
+ * ```
+ */
+export declare const boolean: (name: string) => import("drizzle-orm/sqlite-core").SQLiteBooleanBuilder;
+/**
+ * Creates an enum column with type-safe values.
+ * Stored as text in SQLite with validation at the application level.
+ *
+ * @param name - Column name
+ * @param values - Tuple of allowed string values
+ * @param defaultValue - Optional default value (defaults to first value)
+ * @returns A text column with enum type
+ *
+ * @example
+ * ```ts
+ * const taskPriority = ["low", "medium", "high"] as const;
+ *
+ * const tasks = table("tasks", {
+ *   priority: enums("priority", taskPriority, "medium"),
+ * });
+ * ```
+ */
+export declare const enums: <T extends EnumValues>(name: string, values: T, defaultValue?: T[number]) => import("drizzle-orm").HasDefault<import("drizzle-orm/sqlite-core").SQLiteTextBuilder<import("drizzle-orm").Writable<T>>>;
+/**
+ * Creates a JSON array column with type parameter.
+ *
+ * @param name - Column name
+ * @returns A text column storing JSON with typed array access
+ *
+ * @example
+ * ```ts
+ * const posts = table("posts", {
+ *   // Array of user IDs who liked the post
+ *   likedBy: jsonArray<string[]>("liked_by"),
+ *   // Array of tag objects
+ *   tags: jsonArray<{ id: string; name: string }[]>("tags"),
+ * });
+ * ```
+ */
+export declare const jsonArray: <T = string[]>(name: string) => import("drizzle-orm").$Type<import("drizzle-orm/sqlite-core").SQLiteTextJsonBuilder, T>;
+export {};
+//# sourceMappingURL=helpers.d.ts.map

package/dist/columns/helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../src/columns/helpers.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,IAAI,WAAW,EACpB,OAAO,IAAI,aAAa,EACxB,IAAI,IAAI,UAAU,EAElB,IAAI,IAAI,UAAU,EACnB,MAAM,yBAAyB,CAAC;AAEjC,KAAK,UAAU,GAAG,SAAS,CAAC,MAAM,EAAE,GAAG,MAAM,EAAE,CAAC,CAAC;AAGjD,eAAO,MAAM,KAAK,4DAAc,CAAC;AACjC,eAAO,MAAM,KAAK,oBAAc,CAAC;AACjC,eAAO,MAAM,OAAO,sBAAgB,CAAC;AACrC,eAAO,MAAM,IAAI,mBAAa,CAAC;AAC/B,eAAO,MAAM,IAAI,mBAAa,CAAC;AAE/B;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,OAAO,GAAI,MAAM,MAAM,2DAAuC,CAAC;AAE5E;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,KAAK,GAAI,CAAC,SAAS,UAAU,EAAE,MAAM,MAAM,EAAE,QAAQ,CAAC,EAAE,eAAe,CAAC,CAAC,MAAM,CAAC,6HAGxC,CAAC;AAEtD;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,SAAS,GAAI,CAAC,GAAG,MAAM,EAAE,EAAE,MAAM,MAAM,4FAA4C,CAAC"}

package/dist/columns/index.d.ts

@@ -0,0 +1,5 @@
+export { foreignKey } from "./foreign-key";
+export { boolean, enums, index, integer, jsonArray, real, table, text, } from "./helpers";
+export { primaryKey } from "./primary-key";
+export { createdAt, timestamp, timestamp_ms, updatedAt } from "./timestamps";
+//# sourceMappingURL=index.d.ts.map

package/dist/columns/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/columns/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,EACL,OAAO,EACP,KAAK,EACL,KAAK,EACL,OAAO,EACP,SAAS,EACT,IAAI,EAEJ,KAAK,EACL,IAAI,GACL,MAAM,WAAW,CAAC;AACnB,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC"}

package/dist/columns/primary-key.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Creates a primary key column with auto-generated ULID.
+ *
+ * @param name - Column name (default: "id")
+ * @returns A text column configured as primary key with ULID generation
+ *
+ * @example
+ * ```ts
+ * const users = table("users", {
+ *   id: primaryKey(),
+ *   name: text("name"),
+ * });
+ * ```
+ */
+export declare const primaryKey: (name?: string) => import("drizzle-orm").HasRuntimeDefault<import("drizzle-orm").HasDefault<import("drizzle-orm").NotNull<import("drizzle-orm").IsPrimaryKey<import("drizzle-orm/sqlite-core").SQLiteTextBuilder<[string, ...string[]]>>>>>;
+//# sourceMappingURL=primary-key.d.ts.map

package/dist/columns/primary-key.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"primary-key.d.ts","sourceRoot":"","sources":["../../src/columns/primary-key.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,UAAU,GAAI,aAAW,6NAIT,CAAC"}

package/dist/columns/timestamps.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Creates a timestamp column storing Unix epoch seconds.
+ *
+ * @param columnName - Column name
+ * @returns An integer column in timestamp mode
+ *
+ * @example
+ * ```ts
+ * const events = table("events", {
+ *   occurredAt: timestamp("occurred_at"),
+ * });
+ * ```
+ */
+export declare const timestamp: (columnName: string) => import("drizzle-orm/sqlite-core").SQLiteTimestampBuilder;
+/**
+ * Creates a timestamp column storing Unix epoch milliseconds.
+ *
+ * Use this for BetterAuth plugin tables (api keys, etc.) which expect
+ * `timestamp_ms` mode. Cobaltplan's own tables use `timestamp` (seconds).
+ *
+ * @param columnName - Column name
+ * @returns An integer column in timestamp_ms mode
+ *
+ * @example
+ * ```ts
+ * const apikey = table("apikey", {
+ *   expiresAt: timestampMs("expires_at"),
+ * });
+ * ```
+ */
+export declare const timestamp_ms: (columnName: string) => import("drizzle-orm/sqlite-core").SQLiteTimestampBuilder;
+/**
+ * Creates a created_at timestamp column with automatic default.
+ * Uses SQLite's unixepoch() for the default value.
+ *
+ * @returns A non-null timestamp column defaulting to current time
+ *
+ * @example
+ * ```ts
+ * const users = table("users", {
+ *   id: primaryKey(),
+ *   createdAt: createdAt(),
+ * });
+ * ```
+ */
+export declare const createdAt: () => import("drizzle-orm").HasDefault<import("drizzle-orm").NotNull<import("drizzle-orm/sqlite-core").SQLiteTimestampBuilder>>;
+/**
+ * Creates an updated_at timestamp column with automatic default.
+ * Uses SQLite's unixepoch() for the default value.
+ *
+ * Note: Auto-update on modification requires application-level handling
+ * or a database trigger.
+ *
+ * @returns A non-null timestamp column defaulting to current time
+ *
+ * @example
+ * ```ts
+ * const users = table("users", {
+ *   id: primaryKey(),
+ *   updatedAt: updatedAt(),
+ * });
+ * ```
+ */
+export declare const updatedAt: () => import("drizzle-orm").HasDefault<import("drizzle-orm").NotNull<import("drizzle-orm/sqlite-core").SQLiteTimestampBuilder>>;
+//# sourceMappingURL=timestamps.d.ts.map

package/dist/columns/timestamps.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"timestamps.d.ts","sourceRoot":"","sources":["../../src/columns/timestamps.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,SAAS,GAAI,YAAY,MAAM,6DAA+C,CAAC;AAE5F;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,YAAY,GAAI,YAAY,MAAM,6DAAkD,CAAC;AAElG;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,SAAS,iIAAsE,CAAC;AAE7F;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,SAAS,iIAAsE,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Sizzler
+ *
+ * Workers-safe column factories and utilities for Drizzle ORM with SQLite/D1/Turso.
+ *
+ * For Node.js utilities (seeding, connection helpers), import from:
+ * ```ts
+ * import { getLocalD1Path, createJSONSeeder } from "sizzler/node";
+ * ```
+ *
+ * @example
+ * ```ts
+ * import {
+ *   primaryKey,
+ *   foreignKey,
+ *   createdAt,
+ *   updatedAt,
+ *   table,
+ *   text,
+ * } from "sizzler";
+ *
+ * const users = table("users", {
+ *   id: primaryKey(),
+ *   name: text("name").notNull(),
+ *   createdAt: createdAt(),
+ *   updatedAt: updatedAt(),
+ * });
+ * ```
+ */
+export { boolean, createdAt, enums, foreignKey, index, integer, jsonArray, primaryKey, real, table, text, timestamp, timestamp_ms, updatedAt, } from "./columns";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAGH,OAAO,EACL,OAAO,EACP,SAAS,EACT,KAAK,EACL,UAAU,EACV,KAAK,EACL,OAAO,EACP,SAAS,EACT,UAAU,EACV,IAAI,EAEJ,KAAK,EACL,IAAI,EACJ,SAAS,EACT,YAAY,EACZ,SAAS,GACV,MAAM,WAAW,CAAC"}

package/dist/index.js

@@ -0,0 +1,51 @@
+// src/columns/foreign-key.ts
+import { integer, text } from "drizzle-orm/sqlite-core";
+var foreignKey = (name, col, type = "text", actions) => type === "integer" ? integer(name).references(() => col, actions) : text(name).references(() => col, actions);
+
+// src/columns/helpers.ts
+import {
+  index as sqliteIndex,
+  integer as sqliteInteger,
+  real as sqliteReal,
+  sqliteTable,
+  text as sqliteText
+} from "drizzle-orm/sqlite-core";
+var table = sqliteTable;
+var index = sqliteIndex;
+var integer2 = sqliteInteger;
+var real = sqliteReal;
+var text2 = sqliteText;
+var boolean = (name) => integer2(name, { mode: "boolean" });
+var enums = (name, values, defaultValue) => text2(name, {
+  enum: values
+}).default(defaultValue ? defaultValue : values[0]);
+var jsonArray = (name) => text2(name, { mode: "json" }).$type();
+
+// src/columns/primary-key.ts
+import { text as text3 } from "drizzle-orm/sqlite-core";
+import { ulid } from "ulid";
+var primaryKey = (name = "id") => text3(name).primaryKey().notNull().$defaultFn(() => ulid());
+
+// src/columns/timestamps.ts
+import { sql } from "drizzle-orm";
+import { integer as integer3 } from "drizzle-orm/sqlite-core";
+var timestamp = (columnName) => integer3(columnName, { mode: "timestamp" });
+var timestamp_ms = (columnName) => integer3(columnName, { mode: "timestamp_ms" });
+var createdAt = () => timestamp("created_at").notNull().default(sql`(unixepoch())`);
+var updatedAt = () => timestamp("updated_at").notNull().default(sql`(unixepoch())`);
+export {
+  boolean,
+  createdAt,
+  enums,
+  foreignKey,
+  index,
+  integer2 as integer,
+  jsonArray,
+  primaryKey,
+  real,
+  table,
+  text2 as text,
+  timestamp,
+  timestamp_ms,
+  updatedAt
+};

package/dist/node/connection/d1-helpers.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Compute the SQLite filename that miniflare uses for a D1 database.
+ *
+ * ## Why this exists
+ *
+ * Miniflare (Cloudflare's local dev runtime) stores each D1 database as a
+ * SQLite file with a hashed name — NOT the human-readable `database_id` from
+ * `wrangler.jsonc`. Without this function, scripts that need to create or
+ * locate the database file (migrations, golden DB restore, golden DB create)
+ * would have to start a dev server first and scan the directory for whatever
+ * file appeared — which is fragile and slow.
+ *
+ * ## How the hash works
+ *
+ * Miniflare's `durableObjectNamespaceIdFromName()` algorithm:
+ *
+ * 1. Derive a `key` by SHA-256 hashing the Durable Object unique key
+ *    (always `"miniflare-D1DatabaseObject"` for D1).
+ * 2. HMAC-SHA256 the `database_id` with that key, take the first 16 bytes
+ *    → this is the `nameHmac` (identifies the namespace + name).
+ * 3. HMAC-SHA256 the `nameHmac` with the same key, take the first 16 bytes
+ *    → this is the `hmac` (integrity check).
+ * 4. Concatenate `nameHmac + hmac` (32 bytes) and hex-encode → 64-char filename.
+ * 5. Append `.sqlite`.
+ *
+ * For our `database_id: "3c9d1256-e9bd-4617-ad46-22315915a680"`, this always
+ * produces: `feed28b9d46e13dcb8b4ff9ebe14a54b3b84fc08efd83b1de4251b30f50c9f10.sqlite`
+ *
+ * ## Where it's used
+ *
+ * - `drizzle/migrate-local.ts` — creates the DB file with the correct name
+ * - `scripts/golden-db-restore.ts` — copies snapshot to the correct filename
+ * - `scripts/golden-db-create.ts` — finds the DB file to snapshot
+ * - `getLocalD1Path()` below — locates the DB file for seed scripts
+ *
+ * @param databaseId - The `database_id` from wrangler.jsonc
+ * @returns The hashed filename (e.g., `feed28b9...sqlite`)
+ *
+ * @see https://github.com/cloudflare/workers-sdk — miniflare source
+ */
+export declare function computeD1Filename(databaseId: string): string;
+/**
+ * Get the local D1 database file path for development or testing.
+ *
+ * By default, looks in `.wrangler/state/v3/d1/miniflare-D1DatabaseObject/`.
+ * When TEST_STATE_DIR is set (e.g., TEST_STATE_DIR=.wrangler-test), looks there instead.
+ *
+ * @param bindingName - The D1 binding name from wrangler.json (default: "DB")
+ * @param projectRoot - Project root directory (default: process.cwd())
+ * @returns The absolute path to the SQLite database file
+ *
+ * @example
+ * ```ts
+ * import Database from "better-sqlite3";
+ * import { drizzle } from "drizzle-orm/better-sqlite3";
+ * import { getLocalD1Path } from "sizzler/node";
+ *
+ * const dbPath = getLocalD1Path();
+ * const sqlite = new Database(dbPath);
+ * const db = drizzle({ client: sqlite });
+ * ```
+ */
+export declare function getLocalD1Path(bindingName?: string, projectRoot?: string): string;
+//# sourceMappingURL=d1-helpers.d.ts.map

package/dist/node/connection/d1-helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"d1-helpers.d.ts","sourceRoot":"","sources":["../../../src/node/connection/d1-helpers.ts"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,wBAAgB,iBAAiB,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAa5D;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,cAAc,CAAC,WAAW,SAAO,EAAE,WAAW,GAAE,MAAsB,GAAG,MAAM,CA2C9F"}

package/dist/node/connection/index.d.ts

@@ -0,0 +1,3 @@
+export { computeD1Filename, getLocalD1Path } from "./d1-helpers";
+export { parseWranglerConfig, type WranglerConfig } from "./wrangler-config";
+//# sourceMappingURL=index.d.ts.map

package/dist/node/connection/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/node/connection/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AACjE,OAAO,EAAE,mBAAmB,EAAE,KAAK,cAAc,EAAE,MAAM,mBAAmB,CAAC"}

package/dist/node/connection/wrangler-config.d.ts

@@ -0,0 +1,21 @@
+export interface WranglerConfig {
+    d1_databases?: Array<{
+        binding: string;
+        database_id: string;
+    }>;
+}
+/**
+ * Parse wrangler.json/wrangler.jsonc configuration with JSONC support.
+ * Handles comments and trailing commas.
+ *
+ * @param projectRoot - Project root directory (default: process.cwd())
+ * @returns Parsed Wrangler configuration
+ *
+ * @example
+ * ```ts
+ * const config = parseWranglerConfig();
+ * const dbId = config.d1_databases?.[0]?.database_id;
+ * ```
+ */
+export declare function parseWranglerConfig(projectRoot?: string): WranglerConfig;
+//# sourceMappingURL=wrangler-config.d.ts.map

package/dist/node/connection/wrangler-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wrangler-config.d.ts","sourceRoot":"","sources":["../../../src/node/connection/wrangler-config.ts"],"names":[],"mappings":"AAGA,MAAM,WAAW,cAAc;IAC7B,YAAY,CAAC,EAAE,KAAK,CAAC;QACnB,OAAO,EAAE,MAAM,CAAC;QAChB,WAAW,EAAE,MAAM,CAAC;KACrB,CAAC,CAAC;CACJ;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,mBAAmB,CAAC,WAAW,GAAE,MAAsB,GAAG,cAAc,CA4CvF"}

package/dist/node/index.d.ts

@@ -0,0 +1,4 @@
+export { getLocalD1Path, parseWranglerConfig, type WranglerConfig, } from "./connection";
+export { commonTransformers, createJSONSeeder, type JSONSeederOptions, resetDatabase, } from "./seeding";
+export { type CreateSnapshotOptions, checkpointDatabase, countRows, createSnapshot, type RestoreSnapshotOptions, removeOldSnapshot, removeWalFiles, restoreSnapshot, type SnapshotVerify, verifySnapshot, } from "./snapshot";
+//# sourceMappingURL=index.d.ts.map

package/dist/node/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/node/index.ts"],"names":[],"mappings":"AACA,OAAO,EACL,cAAc,EACd,mBAAmB,EACnB,KAAK,cAAc,GACpB,MAAM,cAAc,CAAC;AAGtB,OAAO,EACL,kBAAkB,EAClB,gBAAgB,EAChB,KAAK,iBAAiB,EACtB,aAAa,GACd,MAAM,WAAW,CAAC;AAGnB,OAAO,EACL,KAAK,qBAAqB,EAC1B,kBAAkB,EAClB,SAAS,EACT,cAAc,EACd,KAAK,sBAAsB,EAC3B,iBAAiB,EACjB,cAAc,EACd,eAAe,EACf,KAAK,cAAc,EACnB,cAAc,GACf,MAAM,YAAY,CAAC"}

package/dist/node/migrate.d.ts

@@ -0,0 +1,22 @@
+export interface RunLocalMigrationsOptions {
+    /** D1 binding name in the wrangler config (e.g. "DB", "WORKGEN_DB"). */
+    bindingName: string;
+    /** Project root holding the wrangler config + `.wrangler` state. Defaults to `process.cwd()`. */
+    projectRoot?: string;
+    /** drizzle-kit migrations folder. Defaults to `<projectRoot>/drizzle/migrations`. */
+    migrationsFolder?: string;
+    /** Progress logger. Defaults to `console.log`. */
+    log?: (message: string) => void;
+}
+/**
+ * Apply drizzle-kit migrations to the local miniflare D1 file for a binding.
+ *
+ * The file is named by hashing the binding's `database_id` — the exact name
+ * miniflare (and the @cloudflare/vite-plugin dev server) uses — so the dev
+ * server reads what this writes. Always targets that hashed name (never a stray
+ * file) and creates it if missing. Honors `TEST_STATE_DIR` for test isolation.
+ *
+ * Requires the optional `better-sqlite3` + `drizzle-orm` peer deps.
+ */
+export declare function runLocalMigrations(options: RunLocalMigrationsOptions): void;
+//# sourceMappingURL=migrate.d.ts.map

package/dist/node/migrate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"migrate.d.ts","sourceRoot":"","sources":["../../src/node/migrate.ts"],"names":[],"mappings":"AAOA,MAAM,WAAW,yBAAyB;IACxC,wEAAwE;IACxE,WAAW,EAAE,MAAM,CAAC;IACpB,iGAAiG;IACjG,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,qFAAqF;IACrF,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,kDAAkD;IAClD,GAAG,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;CACjC;AAED;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,yBAAyB,GAAG,IAAI,CA0B3E"}

package/dist/node/seeding/index.d.ts

@@ -0,0 +1,3 @@
+export { commonTransformers, createJSONSeeder, type JSONSeederOptions, } from "./json-seeder";
+export { resetDatabase } from "./reset";
+//# sourceMappingURL=index.d.ts.map

package/dist/node/seeding/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/node/seeding/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,kBAAkB,EAClB,gBAAgB,EAChB,KAAK,iBAAiB,GACvB,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC"}

package/dist/node/seeding/json-seeder.d.ts

@@ -0,0 +1,59 @@
+export interface JSONSeederOptions {
+    baseDir: string;
+    transformers?: Record<string, (value: unknown) => unknown>;
+}
+/**
+ * Utility for seeding databases from structured JSON files.
+ * Handles date parsing, transformations, and nested directory structures.
+ *
+ * @param options - Configuration options
+ * @returns Object with loadJSON, loadJSONDirectory, and fileExists methods
+ *
+ * @example
+ * ```ts
+ * const seeder = createJSONSeeder({
+ *   baseDir: path.join(__dirname, "seed-data"),
+ *   transformers: {
+ *     ...commonTransformers.dateFields(["createdAt", "updatedAt"]),
+ *   },
+ * });
+ *
+ * const users = seeder.loadJSON<User[]>("users.json");
+ * const posts = seeder.loadJSONDirectory<Post>("posts/");
+ * ```
+ */
+export declare function createJSONSeeder(options: JSONSeederOptions): {
+    loadJSON: <T = unknown>(relativePath: string) => T;
+    loadJSONDirectory: <T = unknown>(relativePath: string) => T[];
+    fileExists: (relativePath: string) => boolean;
+};
+/**
+ * Common transformers for typical database seeding scenarios.
+ */
+export declare const commonTransformers: {
+    /**
+     * Convert ISO date strings to Date objects.
+     *
+     * @example
+     * ```ts
+     * const seeder = createJSONSeeder({
+     *   baseDir: "./seed-data",
+     *   transformers: commonTransformers.dateFields(["createdAt", "updatedAt"]),
+     * });
+     * ```
+     */
+    dateFields: (fieldNames: string[]) => Record<string, (value: unknown) => unknown>;
+    /**
+     * Convert string values to numbers.
+     *
+     * @example
+     * ```ts
+     * const seeder = createJSONSeeder({
+     *   baseDir: "./seed-data",
+     *   transformers: commonTransformers.numberFields(["age", "count"]),
+     * });
+     * ```
+     */
+    numberFields: (fieldNames: string[]) => Record<string, (value: unknown) => unknown>;
+};
+//# sourceMappingURL=json-seeder.d.ts.map

package/dist/node/seeding/json-seeder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"json-seeder.d.ts","sourceRoot":"","sources":["../../../src/node/seeding/json-seeder.ts"],"names":[],"mappings":"AAGA,MAAM,WAAW,iBAAiB;IAChC,OAAO,EAAE,MAAM,CAAC;IAChB,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,OAAO,CAAC,CAAC;CAC5D;AAyBD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,iBAAiB;eAMvC,CAAC,0BAA0B,MAAM,KAAG,CAAC;wBAW5B,CAAC,0BAA0B,MAAM,KAAG,CAAC,EAAE;+BAUhC,MAAM,KAAG,OAAO;EASnD;AAED;;GAEG;AACH,eAAO,MAAM,kBAAkB;IAC7B;;;;;;;;;;OAUG;6BACsB,MAAM,EAAE,4BACY,OAAO,KAAK,OAAO;IAOhE;;;;;;;;;;OAUG;+BACwB,MAAM,EAAE,4BACU,OAAO,KAAK,OAAO;CAMjE,CAAC"}

package/dist/node/seeding/reset.d.ts

@@ -0,0 +1,28 @@
+import type { BaseSQLiteDatabase } from "drizzle-orm/sqlite-core";
+/**
+ * Reset database with enhanced error handling and logging.
+ * Requires explicit confirmation to prevent accidental data loss.
+ *
+ * @param db - Drizzle database instance
+ * @param schema - Database schema object
+ * @param options - Configuration options
+ *
+ * @example
+ * ```ts
+ * import { resetDatabase } from "sizzler/node";
+ *
+ * await resetDatabase(db, schema, {
+ *   confirm: true,
+ *   verbose: true,
+ * });
+ * ```
+ */
+export declare function resetDatabase(db: BaseSQLiteDatabase<"sync" | "async", unknown>, schema: Record<string, unknown>, options?: {
+    confirm?: boolean;
+    verbose?: boolean;
+    logger?: {
+        log: (...args: unknown[]) => void;
+        error: (...args: unknown[]) => void;
+    };
+}): Promise<void>;
+//# sourceMappingURL=reset.d.ts.map

package/dist/node/seeding/reset.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reset.d.ts","sourceRoot":"","sources":["../../../src/node/seeding/reset.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAGlE;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAsB,aAAa,CACjC,EAAE,EAAE,kBAAkB,CAAC,MAAM,GAAG,OAAO,EAAE,OAAO,CAAC,EACjD,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC/B,OAAO,GAAE;IACP,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,MAAM,CAAC,EAAE;QAAE,GAAG,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,IAAI,CAAC;QAAC,KAAK,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,IAAI,CAAA;KAAE,CAAC;CAChF,iBAwBP"}

package/dist/node/snapshot/index.d.ts

@@ -0,0 +1,2 @@
+export { type CreateSnapshotOptions, checkpointDatabase, countRows, createSnapshot, type RestoreSnapshotOptions, removeOldSnapshot, removeWalFiles, restoreSnapshot, type SnapshotVerify, verifySnapshot, } from "./snapshot";
+//# sourceMappingURL=index.d.ts.map

package/dist/node/snapshot/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/node/snapshot/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,qBAAqB,EAC1B,kBAAkB,EAClB,SAAS,EACT,cAAc,EACd,KAAK,sBAAsB,EAC3B,iBAAiB,EACjB,cAAc,EACd,eAAe,EACf,KAAK,cAAc,EACnB,cAAc,GACf,MAAM,YAAY,CAAC"}

package/dist/node/snapshot/snapshot.d.ts

@@ -0,0 +1,63 @@
+/**
+ * SQLite "golden snapshot" utilities — node-only helpers for creating and
+ * restoring self-contained database snapshots (e.g. for E2E test fixtures).
+ *
+ * Pairs with {@link computeD1Filename}/{@link parseWranglerConfig} so callers
+ * can locate a miniflare D1 file and snapshot/restore it. Requires
+ * `better-sqlite3` (an optional peer dependency); these run in node tooling
+ * only, never in a Worker or browser bundle.
+ */
+export interface SnapshotVerify {
+    /** A query selecting a single integer column aliased `count`. */
+    countQuery: string;
+    /** Minimum acceptable count (default 1). */
+    min?: number;
+}
+/** Remove the `-wal` and `-shm` sidecar files for a SQLite database, if present. */
+export declare function removeWalFiles(dbPath: string): void;
+/**
+ * Checkpoint a database file's WAL into its main file and close it, so the
+ * `.sqlite` file is self-contained and safe to copy without its sidecars.
+ */
+export declare function checkpointDatabase(dbPath: string): void;
+/**
+ * Count rows from a read-only query against a SQLite file. The query must
+ * select a single integer column aliased `count`. Does not mutate WAL/SHM.
+ */
+export declare function countRows(dbPath: string, countQuery: string): number;
+/**
+ * Verify a snapshot by running a count query, then clean up any WAL/SHM files
+ * created by opening it read-only. Returns the count.
+ */
+export declare function verifySnapshot(snapshotPath: string, countQuery: string): number;
+/** Delete an existing snapshot and its sidecars; ensure the parent dir exists. */
+export declare function removeOldSnapshot(snapshotPath: string): void;
+export interface CreateSnapshotOptions {
+    /** Verify the created snapshot has the expected data; throws if not. */
+    verify?: SnapshotVerify;
+}
+/**
+ * Create a self-contained snapshot of a live SQLite database.
+ *
+ * Checkpoints the source's WAL into its main file first (so the copy contains
+ * all committed data without needing the `-wal` sidecar), removes any stale
+ * snapshot, copies the main file, and optionally verifies the result.
+ */
+export declare function createSnapshot(sourceDbPath: string, snapshotPath: string, options?: CreateSnapshotOptions): void;
+export interface RestoreSnapshotOptions {
+    /** Reject the snapshot if smaller than this many bytes (corruption guard). */
+    minBytes?: number;
+    /** Verify the restored database after the swap; throws if not. */
+    verify?: SnapshotVerify;
+}
+/**
+ * Restore a snapshot onto a target database path atomically.
+ *
+ * Validates the snapshot exists (and meets `minBytes`), removes the target's
+ * stale WAL/SHM, copies the snapshot to a uniquely-named temp file, then
+ * atomically renames it into place — leaving no window where the target is
+ * missing or half-written, and no chance of SQLite replaying a stale journal
+ * against fresh data. Optionally verifies the restored data.
+ */
+export declare function restoreSnapshot(snapshotPath: string, targetPath: string, options?: RestoreSnapshotOptions): void;
+//# sourceMappingURL=snapshot.d.ts.map

package/dist/node/snapshot/snapshot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"snapshot.d.ts","sourceRoot":"","sources":["../../../src/node/snapshot/snapshot.ts"],"names":[],"mappings":"AAIA;;;;;;;;GAQG;AAEH,MAAM,WAAW,cAAc;IAC7B,iEAAiE;IACjE,UAAU,EAAE,MAAM,CAAC;IACnB,4CAA4C;IAC5C,GAAG,CAAC,EAAE,MAAM,CAAC;CACd;AAED,oFAAoF;AACpF,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAInD;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAOvD;AAED;;;GAGG;AACH,wBAAgB,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM,CAQpE;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAAC,YAAY,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM,CAM/E;AAED,kFAAkF;AAClF,wBAAgB,iBAAiB,CAAC,YAAY,EAAE,MAAM,GAAG,IAAI,CAO5D;AAED,MAAM,WAAW,qBAAqB;IACpC,wEAAwE;IACxE,MAAM,CAAC,EAAE,cAAc,CAAC;CACzB;AAED;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,YAAY,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,OAAO,GAAE,qBAA0B,GAAG,IAAI,CAkBpH;AAED,MAAM,WAAW,sBAAsB;IACrC,8EAA8E;IAC9E,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,kEAAkE;IAClE,MAAM,CAAC,EAAE,cAAc,CAAC;CACzB;AAED;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAAC,YAAY,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,OAAO,GAAE,sBAA2B,GAAG,IAAI,CA+BpH"}

package/dist/node.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Node.js utilities for Sizzler.
+ *
+ * These utilities require Node.js APIs (fs, path) and should NOT be imported
+ * in Cloudflare Workers or browser code.
+ *
+ * @example
+ * ```ts
+ * import {
+ *   getLocalD1Path,
+ *   createJSONSeeder,
+ *   resetDatabase,
+ * } from "sizzler/node";
+ *
+ * // Get local D1 database path
+ * const dbPath = getLocalD1Path();
+ *
+ * // Create a JSON seeder
+ * const seeder = createJSONSeeder({
+ *   baseDir: "./seed-data",
+ * });
+ * ```
+ */
+export { computeD1Filename, getLocalD1Path, parseWranglerConfig, type WranglerConfig, } from "./node/connection";
+export { type RunLocalMigrationsOptions, runLocalMigrations } from "./node/migrate";
+export { commonTransformers, createJSONSeeder, type JSONSeederOptions, resetDatabase, } from "./node/seeding";
+export { type CreateSnapshotOptions, checkpointDatabase, countRows, createSnapshot, type RestoreSnapshotOptions, removeOldSnapshot, removeWalFiles, restoreSnapshot, type SnapshotVerify, verifySnapshot, } from "./node/snapshot";
+//# sourceMappingURL=node.d.ts.map

package/dist/node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node.d.ts","sourceRoot":"","sources":["../src/node.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAGH,OAAO,EACL,iBAAiB,EACjB,cAAc,EACd,mBAAmB,EACnB,KAAK,cAAc,GACpB,MAAM,mBAAmB,CAAC;AAG3B,OAAO,EAAE,KAAK,yBAAyB,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAC;AAGpF,OAAO,EACL,kBAAkB,EAClB,gBAAgB,EAChB,KAAK,iBAAiB,EACtB,aAAa,GACd,MAAM,gBAAgB,CAAC;AAIxB,OAAO,EACL,KAAK,qBAAqB,EAC1B,kBAAkB,EAClB,SAAS,EACT,cAAc,EACd,KAAK,sBAAsB,EAC3B,iBAAiB,EACjB,cAAc,EACd,eAAe,EACf,KAAK,cAAc,EACnB,cAAc,GACf,MAAM,iBAAiB,CAAC"}

package/dist/node.js

@@ -0,0 +1,310 @@
+// src/node/connection/d1-helpers.ts
+import { createHash, createHmac } from "crypto";
+import { readdirSync } from "fs";
+import { join as join2 } from "path";
+
+// src/node/connection/wrangler-config.ts
+import { readFileSync } from "fs";
+import { join } from "path";
+function parseWranglerConfig(projectRoot = process.cwd()) {
+  let wranglerPath = join(projectRoot, "wrangler.json");
+  try {
+    readFileSync(wranglerPath, "utf8");
+  } catch {
+    wranglerPath = join(projectRoot, "wrangler.jsonc");
+  }
+  const content = readFileSync(wranglerPath, "utf8");
+  const cleanedContent = content.split("\n").map((line) => {
+    let inString = false;
+    let escaped = false;
+    for (let i = 0; i < line.length; i++) {
+      const char = line[i];
+      if (escaped) {
+        escaped = false;
+        continue;
+      }
+      if (char === "\\" && inString) {
+        escaped = true;
+        continue;
+      }
+      if (char === '"') {
+        inString = !inString;
+        continue;
+      }
+      if (!inString && line.substring(i, i + 2) === "//") {
+        return line.slice(0, i).trim();
+      }
+    }
+    return line;
+  }).join("\n").replace(/\/\*[\s\S]*?\*\//g, "").replace(/,(\s*[}\]])/g, "$1");
+  return JSON.parse(cleanedContent);
+}
+
+// src/node/connection/d1-helpers.ts
+function computeD1Filename(databaseId) {
+  const uniqueKey = "miniflare-D1DatabaseObject";
+  const key = createHash("sha256").update(uniqueKey).digest();
+  const nameHmac = createHmac("sha256", key).update(databaseId).digest().subarray(0, 16);
+  const hmac = createHmac("sha256", key).update(nameHmac).digest().subarray(0, 16);
+  return Buffer.concat([nameHmac, hmac]).toString("hex") + ".sqlite";
+}
+function getLocalD1Path(bindingName = "DB", projectRoot = process.cwd()) {
+  const stateDir = process.env.TEST_STATE_DIR;
+  const wranglerConfig = parseWranglerConfig(projectRoot);
+  const dbConfig = wranglerConfig.d1_databases?.find((d) => d.binding === bindingName);
+  if (!dbConfig) {
+    throw new Error(`Database binding '${bindingName}' not found in wrangler.json/wrangler.jsonc`);
+  }
+  const d1Dir = stateDir ? join2(projectRoot, `${stateDir}/v3/d1/miniflare-D1DatabaseObject`) : join2(projectRoot, ".wrangler/state/v3/d1/miniflare-D1DatabaseObject");
+  const expectedFilename = computeD1Filename(dbConfig.database_id);
+  const expectedPath = join2(d1Dir, expectedFilename);
+  try {
+    const files = readdirSync(d1Dir).filter((file) => file.endsWith(".sqlite"));
+    if (files.length === 0) {
+      throw new Error(`No D1 database found in ${d1Dir}. Run migrations first (npm run db:migrate).`);
+    }
+    if (files.includes(expectedFilename)) {
+      return expectedPath;
+    }
+    return join2(d1Dir, files[0]);
+  } catch (error) {
+    if (error instanceof Error && error.message.includes("No D1 database")) {
+      throw error;
+    }
+    throw new Error(`No D1 database directory found at ${d1Dir}. Run migrations first (npm run db:migrate).`);
+  }
+}
+
+// src/node/migrate.ts
+import { mkdirSync } from "fs";
+import { join as join3 } from "path";
+import Database from "better-sqlite3";
+import { drizzle } from "drizzle-orm/better-sqlite3";
+import { migrate } from "drizzle-orm/better-sqlite3/migrator";
+function runLocalMigrations(options) {
+  const { bindingName, projectRoot = process.cwd(), log = console.log } = options;
+  const migrationsFolder = options.migrationsFolder ?? join3(projectRoot, "drizzle", "migrations");
+  const stateDir = process.env.TEST_STATE_DIR;
+  const d1Dir = stateDir ? join3(projectRoot, stateDir, "v3", "d1", "miniflare-D1DatabaseObject") : join3(projectRoot, ".wrangler", "state", "v3", "d1", "miniflare-D1DatabaseObject");
+  mkdirSync(d1Dir, { recursive: true });
+  const dbConfig = parseWranglerConfig(projectRoot).d1_databases?.find((d) => d.binding === bindingName);
+  if (!dbConfig) {
+    throw new Error(`No D1 database binding '${bindingName}' found in wrangler config`);
+  }
+  const dbPath = join3(d1Dir, computeD1Filename(dbConfig.database_id));
+  log(`\u{1F4C2} Database: ${dbPath}`);
+  const sqlite = new Database(dbPath);
+  try {
+    migrate(drizzle({ client: sqlite }), { migrationsFolder });
+    log("\u2705 Migrations applied successfully");
+  } finally {
+    sqlite.close();
+  }
+}
+
+// src/node/seeding/json-seeder.ts
+import fs from "fs";
+import path from "path";
+function applyTransformers(data, transformers) {
+  if (Array.isArray(data)) {
+    return data.map((item) => applyTransformers(item, transformers));
+  }
+  if (data && typeof data === "object") {
+    const result = {};
+    for (const [key, value] of Object.entries(data)) {
+      if (transformers[key]) {
+        result[key] = transformers[key](value);
+      } else {
+        result[key] = applyTransformers(value, transformers);
+      }
+    }
+    return result;
+  }
+  return data;
+}
+function createJSONSeeder(options) {
+  const { baseDir, transformers = {} } = options;
+  function loadJSON(relativePath) {
+    const filePath = path.join(baseDir, relativePath);
+    const content = fs.readFileSync(filePath, "utf-8");
+    const data = JSON.parse(content);
+    return applyTransformers(data, transformers);
+  }
+  function loadJSONDirectory(relativePath) {
+    const dirPath = path.join(baseDir, relativePath);
+    const files = fs.readdirSync(dirPath).filter((file) => file.endsWith(".json"));
+    return files.map((file) => loadJSON(path.join(relativePath, file)));
+  }
+  function fileExists(relativePath) {
+    return fs.existsSync(path.join(baseDir, relativePath));
+  }
+  return {
+    loadJSON,
+    loadJSONDirectory,
+    fileExists
+  };
+}
+var commonTransformers = {
+  /**
+   * Convert ISO date strings to Date objects.
+   *
+   * @example
+   * ```ts
+   * const seeder = createJSONSeeder({
+   *   baseDir: "./seed-data",
+   *   transformers: commonTransformers.dateFields(["createdAt", "updatedAt"]),
+   * });
+   * ```
+   */
+  dateFields: (fieldNames) => {
+    const transformers = {};
+    fieldNames.forEach((field) => {
+      transformers[field] = (value) => new Date(value);
+    });
+    return transformers;
+  },
+  /**
+   * Convert string values to numbers.
+   *
+   * @example
+   * ```ts
+   * const seeder = createJSONSeeder({
+   *   baseDir: "./seed-data",
+   *   transformers: commonTransformers.numberFields(["age", "count"]),
+   * });
+   * ```
+   */
+  numberFields: (fieldNames) => {
+    const transformers = {};
+    fieldNames.forEach((field) => {
+      transformers[field] = (value) => Number(value);
+    });
+    return transformers;
+  }
+};
+
+// src/node/seeding/reset.ts
+import { reset } from "drizzle-seed";
+async function resetDatabase(db, schema, options = {}) {
+  const { confirm = false, verbose = false, logger = console } = options;
+  if (!confirm) {
+    throw new Error("Database reset requires explicit confirmation. Set confirm: true");
+  }
+  try {
+    if (verbose) {
+      logger.log("Resetting database...");
+    }
+    await reset(db, schema);
+    if (verbose) {
+      logger.log("Database reset completed successfully.");
+    }
+  } catch (error) {
+    if (verbose) {
+      logger.error("Database reset failed:", error);
+    }
+    throw error;
+  }
+}
+
+// src/node/snapshot/snapshot.ts
+import { copyFileSync, existsSync, mkdirSync as mkdirSync2, renameSync, rmSync, statSync } from "fs";
+import { dirname } from "path";
+import Database2 from "better-sqlite3";
+function removeWalFiles(dbPath) {
+  for (const suffix of ["-wal", "-shm"]) {
+    rmSync(`${dbPath}${suffix}`, { force: true });
+  }
+}
+function checkpointDatabase(dbPath) {
+  const db = new Database2(dbPath);
+  try {
+    db.pragma("wal_checkpoint(TRUNCATE)");
+  } finally {
+    db.close();
+  }
+}
+function countRows(dbPath, countQuery) {
+  const db = new Database2(dbPath, { readonly: true });
+  try {
+    const row = db.prepare(countQuery).get();
+    return row?.count ?? 0;
+  } finally {
+    db.close();
+  }
+}
+function verifySnapshot(snapshotPath, countQuery) {
+  try {
+    return countRows(snapshotPath, countQuery);
+  } finally {
+    removeWalFiles(snapshotPath);
+  }
+}
+function removeOldSnapshot(snapshotPath) {
+  const dir = dirname(snapshotPath);
+  if (!existsSync(dir)) mkdirSync2(dir, { recursive: true });
+  if (existsSync(snapshotPath)) {
+    rmSync(snapshotPath, { force: true });
+    removeWalFiles(snapshotPath);
+  }
+}
+function createSnapshot(sourceDbPath, snapshotPath, options = {}) {
+  if (!existsSync(sourceDbPath)) {
+    throw new Error(`Cannot create snapshot: source database not found at ${sourceDbPath}`);
+  }
+  checkpointDatabase(sourceDbPath);
+  removeOldSnapshot(snapshotPath);
+  copyFileSync(sourceDbPath, snapshotPath);
+  if (options.verify) {
+    const { countQuery, min = 1 } = options.verify;
+    const count = verifySnapshot(snapshotPath, countQuery);
+    if (count < min) {
+      throw new Error(
+        `Snapshot verification failed: \`${countQuery}\` returned ${count} (expected >= ${min}).
+  Snapshot: ${snapshotPath}`
+      );
+    }
+  }
+}
+function restoreSnapshot(snapshotPath, targetPath, options = {}) {
+  const { minBytes = 1, verify } = options;
+  if (!existsSync(snapshotPath)) {
+    throw new Error(`Cannot restore: snapshot not found at ${snapshotPath}`);
+  }
+  const size = statSync(snapshotPath).size;
+  if (size < minBytes) {
+    throw new Error(
+      `Cannot restore: snapshot at ${snapshotPath} is ${size} bytes (expected >= ${minBytes}). Likely corrupt \u2014 recreate it.`
+    );
+  }
+  mkdirSync2(dirname(targetPath), { recursive: true });
+  removeWalFiles(targetPath);
+  const tmpPath = `${targetPath}.tmp.${process.pid}.${Date.now()}`;
+  copyFileSync(snapshotPath, tmpPath);
+  renameSync(tmpPath, targetPath);
+  if (verify) {
+    const { countQuery, min = 1 } = verify;
+    const count = verifySnapshot(targetPath, countQuery);
+    if (count < min) {
+      throw new Error(
+        `Restore verification failed: \`${countQuery}\` returned ${count} (expected >= ${min}).
+  Target: ${targetPath}`
+      );
+    }
+  }
+}
+export {
+  checkpointDatabase,
+  commonTransformers,
+  computeD1Filename,
+  countRows,
+  createJSONSeeder,
+  createSnapshot,
+  getLocalD1Path,
+  parseWranglerConfig,
+  removeOldSnapshot,
+  removeWalFiles,
+  resetDatabase,
+  restoreSnapshot,
+  runLocalMigrations,
+  verifySnapshot
+};

package/package.json

@@ -0,0 +1,79 @@
+{
+  "name": "@chromav/sizzler",
+  "version": "0.1.1",
+  "description": "Sizzling column factories and utilities for Drizzle ORM with SQLite, D1, and Turso",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./node": {
+      "import": "./dist/node.js",
+      "types": "./dist/node.d.ts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup && tsc -p tsconfig.build.json --emitDeclarationOnly",
+    "dev": "tsup --watch",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "typecheck": "tsc --noEmit"
+  },
+  "peerDependencies": {
+    "better-sqlite3": ">=11.0.0",
+    "drizzle-orm": ">=0.30.0 || >=1.0.0-beta.1",
+    "drizzle-seed": ">=0.1.0"
+  },
+  "peerDependenciesMeta": {
+    "better-sqlite3": {
+      "optional": true
+    },
+    "drizzle-seed": {
+      "optional": true
+    }
+  },
+  "dependencies": {
+    "ulid": "^3.0.2"
+  },
+  "devDependencies": {
+    "@types/better-sqlite3": "^7.6.13",
+    "better-sqlite3": "^12.0.0",
+    "drizzle-orm": "1.0.0-beta.22",
+    "drizzle-seed": "^1.0.0-beta.22",
+    "tsup": "^8.5.1",
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.5"
+  },
+  "keywords": [
+    "sizzler",
+    "drizzle",
+    "orm",
+    "sqlite",
+    "d1",
+    "cloudflare",
+    "turso",
+    "column-factories",
+    "ulid"
+  ],
+  "author": "Cobaltplan",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/chroma-v/kindling.git",
+    "directory": "packages/sizzler"
+  },
+  "homepage": "https://github.com/chroma-v/kindling/tree/main/packages/sizzler#readme",
+  "bugs": {
+    "url": "https://github.com/chroma-v/kindling/issues"
+  }
+}