mundane-sdk 0.0.1 → 0.1.0

package/dist/src/errors.d.ts

@@ -1,31 +1,31 @@
 /**
  * Custom error classes thrown by mundane.
  *
- * - MundaneLockedError: another live process holds the file lock.
- * - MundaneSerializationError: a step's return value doesn't survive a
+ * - LockedError: another live process holds the file lock.
+ * - SerializationError: a step's return value doesn't survive a
  *   JSON round-trip (Date, undefined, BigInt, Map, Set, function, circular).
- * - MundaneSchemaError: file exists but meta.schema_version != "1".
- * - MundaneStepFailedError: a step body threw; wraps the underlying error.
+ * - SchemaError: file exists but meta.schema_version != "1".
+ * - StepFailedError: a step body threw; wraps the underlying error.
  */
-export declare class MundaneLockedError extends Error {
+export declare class LockedError extends Error {
     readonly code = "EMUNDANELOCKED";
     constructor(message: string);
 }
-export declare class MundaneSerializationError extends Error {
+export declare class SerializationError extends Error {
     readonly code = "EMUNDANESERIALIZATION";
     readonly path?: string;
     constructor(message: string, path?: string);
 }
-export declare class MundaneSchemaError extends Error {
+export declare class SchemaError extends Error {
     readonly code = "EMUNDANESCHEMA";
     constructor(message: string);
 }
-export declare class MundaneDuplicateStepError extends Error {
+export declare class DuplicateStepError extends Error {
     readonly code = "EMUNDANEDUPLICATE";
     readonly stepName: string;
     constructor(stepName: string);
 }
-export declare class MundaneStepFailedError extends Error {
+export declare class StepFailedError extends Error {
     readonly code = "EMUNDANESTEPFAILED";
     readonly stepName: string;
     readonly original: unknown;

package/dist/src/errors.js

@@ -2,51 +2,51 @@
 /**
  * Custom error classes thrown by mundane.
  *
- * - MundaneLockedError: another live process holds the file lock.
- * - MundaneSerializationError: a step's return value doesn't survive a
+ * - LockedError: another live process holds the file lock.
+ * - SerializationError: a step's return value doesn't survive a
  *   JSON round-trip (Date, undefined, BigInt, Map, Set, function, circular).
- * - MundaneSchemaError: file exists but meta.schema_version != "1".
- * - MundaneStepFailedError: a step body threw; wraps the underlying error.
+ * - SchemaError: file exists but meta.schema_version != "1".
+ * - StepFailedError: a step body threw; wraps the underlying error.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MundaneStepFailedError = exports.MundaneDuplicateStepError = exports.MundaneSchemaError = exports.MundaneSerializationError = exports.MundaneLockedError = void 0;
-class MundaneLockedError extends Error {
+exports.StepFailedError = exports.DuplicateStepError = exports.SchemaError = exports.SerializationError = exports.LockedError = void 0;
+class LockedError extends Error {
     code = "EMUNDANELOCKED";
     constructor(message) {
         super(message);
-        this.name = "MundaneLockedError";
+        this.name = "LockedError";
     }
 }
-exports.MundaneLockedError = MundaneLockedError;
-class MundaneSerializationError extends Error {
+exports.LockedError = LockedError;
+class SerializationError extends Error {
     code = "EMUNDANESERIALIZATION";
     path;
     constructor(message, path) {
         super(message);
-        this.name = "MundaneSerializationError";
+        this.name = "SerializationError";
         this.path = path;
     }
 }
-exports.MundaneSerializationError = MundaneSerializationError;
-class MundaneSchemaError extends Error {
+exports.SerializationError = SerializationError;
+class SchemaError extends Error {
     code = "EMUNDANESCHEMA";
     constructor(message) {
         super(message);
-        this.name = "MundaneSchemaError";
+        this.name = "SchemaError";
     }
 }
-exports.MundaneSchemaError = MundaneSchemaError;
-class MundaneDuplicateStepError extends Error {
+exports.SchemaError = SchemaError;
+class DuplicateStepError extends Error {
     code = "EMUNDANEDUPLICATE";
     stepName;
     constructor(stepName) {
         super(`duplicate step name: ${stepName}`);
-        this.name = "MundaneDuplicateStepError";
+        this.name = "DuplicateStepError";
         this.stepName = stepName;
     }
 }
-exports.MundaneDuplicateStepError = MundaneDuplicateStepError;
-class MundaneStepFailedError extends Error {
+exports.DuplicateStepError = DuplicateStepError;
+class StepFailedError extends Error {
     code = "EMUNDANESTEPFAILED";
     stepName;
     original;
@@ -55,7 +55,7 @@ class MundaneStepFailedError extends Error {
             ? `step ${JSON.stringify(stepName)} failed: ${original.message}`
             : `step ${JSON.stringify(stepName)} failed: ${String(original)}`;
         super(msg);
-        this.name = "MundaneStepFailedError";
+        this.name = "StepFailedError";
         this.stepName = stepName;
         this.original = original;
         if (original instanceof Error && original.stack) {
@@ -63,4 +63,4 @@ class MundaneStepFailedError extends Error {
         }
     }
 }
-exports.MundaneStepFailedError = MundaneStepFailedError;
+exports.StepFailedError = StepFailedError;

package/dist/src/index.d.ts

@@ -8,8 +8,8 @@
  *
  * See ../../../SPEC.md (project root) for the full contract.
  */
-import { MundaneDuplicateStepError, MundaneLockedError, MundaneSchemaError, MundaneSerializationError, MundaneStepFailedError } from "./errors";
-export { MundaneDuplicateStepError, MundaneLockedError, MundaneSchemaError, MundaneSerializationError, MundaneStepFailedError, };
+import { DuplicateStepError, LockedError, SchemaError, SerializationError, StepFailedError } from "./errors";
+export { DuplicateStepError, LockedError, SchemaError, SerializationError, StepFailedError };
 export type Json = null | boolean | number | string | Json[] | {
     [k: string]: Json;
 };

package/dist/src/index.js

@@ -10,16 +10,16 @@
  * See ../../../SPEC.md (project root) for the full contract.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MundaneStepFailedError = exports.MundaneSerializationError = exports.MundaneSchemaError = exports.MundaneLockedError = exports.MundaneDuplicateStepError = void 0;
+exports.StepFailedError = exports.SerializationError = exports.SchemaError = exports.LockedError = exports.DuplicateStepError = void 0;
 exports.run = run;
 const db_1 = require("./db");
 const duration_1 = require("./duration");
 const errors_1 = require("./errors");
-Object.defineProperty(exports, "MundaneDuplicateStepError", { enumerable: true, get: function () { return errors_1.MundaneDuplicateStepError; } });
-Object.defineProperty(exports, "MundaneLockedError", { enumerable: true, get: function () { return errors_1.MundaneLockedError; } });
-Object.defineProperty(exports, "MundaneSchemaError", { enumerable: true, get: function () { return errors_1.MundaneSchemaError; } });
-Object.defineProperty(exports, "MundaneSerializationError", { enumerable: true, get: function () { return errors_1.MundaneSerializationError; } });
-Object.defineProperty(exports, "MundaneStepFailedError", { enumerable: true, get: function () { return errors_1.MundaneStepFailedError; } });
+Object.defineProperty(exports, "DuplicateStepError", { enumerable: true, get: function () { return errors_1.DuplicateStepError; } });
+Object.defineProperty(exports, "LockedError", { enumerable: true, get: function () { return errors_1.LockedError; } });
+Object.defineProperty(exports, "SchemaError", { enumerable: true, get: function () { return errors_1.SchemaError; } });
+Object.defineProperty(exports, "SerializationError", { enumerable: true, get: function () { return errors_1.SerializationError; } });
+Object.defineProperty(exports, "StepFailedError", { enumerable: true, get: function () { return errors_1.StepFailedError; } });
 const lock_1 = require("./lock");
 const names_1 = require("./names");
 const schema_1 = require("./schema");
@@ -29,16 +29,16 @@ function checkJsonRoundtrip(value) {
         text = JSON.stringify(value);
     }
     catch (e) {
-        throw new errors_1.MundaneSerializationError(`value is not JSON-serializable: ${e.message}`);
+        throw new errors_1.SerializationError(`value is not JSON-serializable: ${e.message}`);
     }
     if (text === undefined) {
         // JSON.stringify returns undefined for top-level undefined/function/symbol
-        throw new errors_1.MundaneSerializationError("value is not JSON-serializable (undefined / function / symbol at top level)");
+        throw new errors_1.SerializationError("value is not JSON-serializable (undefined / function / symbol at top level)");
     }
     const decoded = JSON.parse(text);
     const mismatch = deepDiff(value, decoded, "");
     if (mismatch !== null) {
-        throw new errors_1.MundaneSerializationError(`value does not round-trip through JSON at ${JSON.stringify(mismatch)}`, mismatch);
+        throw new errors_1.SerializationError(`value does not round-trip through JSON at ${JSON.stringify(mismatch)}`, mismatch);
     }
     return text;
 }
@@ -109,12 +109,12 @@ class TaskState {
     }
     checkSeen(name) {
         if (this.seen.has(name)) {
-            throw new errors_1.MundaneDuplicateStepError(name);
+            throw new errors_1.DuplicateStepError(name);
         }
         this.seen.add(name);
     }
     async loadCache() {
-        const rows = await this.db.all("SELECT id, name, kind, encoding, result, status, error FROM mundane_steps ORDER BY id");
+        const rows = await this.db.all("SELECT name, kind, encoding, result, status, error FROM mundane_steps ORDER BY id");
         for (const row of rows)
             this.cache.set(row.name, row);
     }
@@ -132,10 +132,9 @@ class TaskState {
             existing.error = null;
             return existing;
         }
-        const now = new Date().toISOString();
         await this.db.run("INSERT INTO mundane_steps (name, kind, encoding, result, status, started_at) " +
-            "VALUES (?, ?, ?, NULL, 'pending', ?)", [name, kind, encoding, now]);
-        const row = (await this.db.get("SELECT id, name, kind, encoding, result, status, error FROM mundane_steps WHERE name = ?", [name]));
+            "VALUES (?, ?, ?, NULL, 'pending', ?)", [name, kind, encoding, new Date().toISOString()]);
+        const row = { name, kind, encoding, result: null, status: "pending", error: null };
         this.cache.set(name, row);
         return row;
     }
@@ -176,7 +175,7 @@ class ContextImpl {
         catch (e) {
             const msg = e instanceof Error ? e.message : String(e);
             await this.task.commitFailed(name, msg);
-            throw new errors_1.MundaneStepFailedError(name, e);
+            throw new errors_1.StepFailedError(name, e);
         }
         const text = checkJsonRoundtrip(value);
         await this.task.commitDone(name, "json", text);
@@ -205,15 +204,7 @@ class ContextImpl {
     }
 }
 async function run(path, fn) {
-    let lock;
-    try {
-        lock = await (0, lock_1.acquireLock)(path);
-    }
-    catch (e) {
-        if (e instanceof errors_1.MundaneLockedError)
-            throw e;
-        throw e;
-    }
+    const lock = await (0, lock_1.acquireLock)(path);
     let db = null;
     try {
         db = await (0, db_1.openDb)(path);

package/dist/src/lock.js

@@ -53,7 +53,7 @@ async function acquireLock(path) {
         await closeFd(fd);
         const code = e.code;
         if (code === "EWOULDBLOCK" || code === "EAGAIN") {
-            throw new errors_1.MundaneLockedError(`${path}: locked by another process`);
+            throw new errors_1.LockedError(`${path}: locked by another process`);
         }
         throw e;
     }

package/dist/src/names.d.ts

@@ -1,6 +1,6 @@
 /**
  * Step-name validation. Names must match /^[A-Za-z0-9][A-Za-z0-9._-]*$/.
- * Duplicate names within one task body raise MundaneDuplicateStepError;
+ * Duplicate names within one task body raise DuplicateStepError;
  * see ../src/index.ts.
  */
 export declare function validateName(name: string): void;

package/dist/src/names.js

@@ -1,7 +1,7 @@
 "use strict";
 /**
  * Step-name validation. Names must match /^[A-Za-z0-9][A-Za-z0-9._-]*$/.
- * Duplicate names within one task body raise MundaneDuplicateStepError;
+ * Duplicate names within one task body raise DuplicateStepError;
  * see ../src/index.ts.
  */
 Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/schema.js

@@ -42,7 +42,7 @@ async function bootstrap(db) {
     if (existing) {
         const row = await db.get("SELECT value FROM mundane_meta WHERE key='schema_version'");
         if (row && row.value !== exports.SCHEMA_VERSION) {
-            throw new errors_1.MundaneSchemaError(`schema_version is ${JSON.stringify(row.value)}, expected "${exports.SCHEMA_VERSION}"`);
+            throw new errors_1.SchemaError(`schema_version is ${JSON.stringify(row.value)}, expected "${exports.SCHEMA_VERSION}"`);
         }
     }
     await db.exec("BEGIN IMMEDIATE");
@@ -50,15 +50,13 @@ async function bootstrap(db) {
         await db.exec(exports.CREATE_META);
         await db.exec(exports.CREATE_STEPS);
         await db.exec(exports.CREATE_INDEX);
-        await db.run("INSERT OR IGNORE INTO mundane_meta (key, value) VALUES ('schema_version', ?)", [
-            exports.SCHEMA_VERSION,
-        ]);
-        await db.run("INSERT OR IGNORE INTO mundane_meta (key, value) VALUES ('task_id', ?)", [
-            (0, node_crypto_1.randomUUID)(),
-        ]);
-        await db.run("INSERT OR IGNORE INTO mundane_meta (key, value) VALUES ('created_at', ?)", [
-            new Date().toISOString(),
-        ]);
+        for (const [key, value] of [
+            ["schema_version", exports.SCHEMA_VERSION],
+            ["task_id", (0, node_crypto_1.randomUUID)()],
+            ["created_at", new Date().toISOString()],
+        ]) {
+            await db.run("INSERT OR IGNORE INTO mundane_meta (key, value) VALUES (?, ?)", [key, value]);
+        }
         await db.exec("COMMIT");
     }
     catch (e) {
@@ -71,6 +69,6 @@ async function bootstrap(db) {
     // Final check.
     const row = await db.get("SELECT value FROM mundane_meta WHERE key='schema_version'");
     if (!row || row.value !== exports.SCHEMA_VERSION) {
-        throw new errors_1.MundaneSchemaError(`schema_version is ${JSON.stringify(row?.value)}, expected "${exports.SCHEMA_VERSION}"`);
+        throw new errors_1.SchemaError(`schema_version is ${JSON.stringify(row?.value)}, expected "${exports.SCHEMA_VERSION}"`);
     }
 }

package/dist/test/basic.test.js

@@ -110,13 +110,13 @@ function newDb() {
         cleanup();
     }
 });
-(0, node_test_1.test)("duplicate step name raises MundaneDuplicateStepError", async () => {
+(0, node_test_1.test)("duplicate step name raises DuplicateStepError", async () => {
     const { path, cleanup } = newDb();
     try {
         await strict_1.default.rejects((0, index_1.run)(path, async (ctx) => {
             await ctx.step("x", async () => 1);
             await ctx.step("x", async () => 2);
-        }), (e) => e instanceof index_1.MundaneDuplicateStepError && e.stepName === "x");
+        }), (e) => e instanceof index_1.DuplicateStepError && e.stepName === "x");
         // First step still committed before the dup raised.
         const names = (await readSteps(path)).map((s) => s.name);
         strict_1.default.deepEqual(names, ["x"]);
@@ -166,7 +166,7 @@ function newDb() {
     const { path, cleanup } = newDb();
     try {
         // Back-to-back runs: if release() resolved before the helper actually
-        // dropped the flock, a later run would throw MundaneLockedError.
+        // dropped the flock, a later run would throw LockedError.
         for (let i = 0; i < 5; i++) {
             await (0, index_1.run)(path, async (ctx) => ctx.step(`s${i}`, async () => i));
         }
@@ -177,18 +177,18 @@ function newDb() {
         cleanup();
     }
 });
-(0, node_test_1.test)("non-JSON value raises MundaneSerializationError", async () => {
+(0, node_test_1.test)("non-JSON value raises SerializationError", async () => {
     const { path, cleanup } = newDb();
     try {
         await strict_1.default.rejects((0, index_1.run)(path, async (ctx) => {
             await ctx.step("a", async () => new Date());
-        }), (e) => e instanceof index_1.MundaneSerializationError);
+        }), (e) => e instanceof index_1.SerializationError);
     }
     finally {
         cleanup();
     }
 });
-(0, node_test_1.test)("locked task throws MundaneLockedError", async () => {
+(0, node_test_1.test)("locked task throws LockedError", async () => {
     const { path, cleanup } = newDb();
     try {
         let unblock;
@@ -202,7 +202,7 @@ function newDb() {
         });
         // Give the first run time to acquire the lock.
         await new Promise((r) => setTimeout(r, 200));
-        await strict_1.default.rejects((0, index_1.run)(path, async () => { }), (e) => e instanceof index_1.MundaneLockedError);
+        await strict_1.default.rejects((0, index_1.run)(path, async () => { }), (e) => e instanceof index_1.LockedError);
         unblock();
         await first;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mundane-sdk",
-  "version": "0.0.1",
+  "version": "0.1.0",
   "description": "Tiny durable-execution: one workflow run is one SQLite file.",
   "license": "MIT",
   "repository": {