@lunora/testing 0.0.0 → 1.0.0-alpha.2

package/dist/packem_shared/lunoraTest-BUg4Ebv8.mjs

@@ -0,0 +1,415 @@
+import { runShardMigrations, createShardCtxDb } from '@lunora/do';
+import { DatabaseSync } from 'node:sqlite';
+
+const createFakeScheduler = (getDispatch, getMutationContext, getFunctionRegistry) => {
+  let nowMs = Date.now();
+  let nextId = 1;
+  const pending = /* @__PURE__ */ new Map();
+  const recordedFailures = [];
+  const enqueue = (scheduledFor, functionPath, args = {}) => {
+    const id = `fake-job-${String(nextId)}`;
+    nextId += 1;
+    pending.set(id, {
+      args,
+      enqueuedAt: nowMs,
+      functionPath,
+      id,
+      scheduledFor
+    });
+    return id;
+  };
+  const scheduler = {
+    cancel: (id) => {
+      const existed = pending.has(id);
+      pending.delete(id);
+      return Promise.resolve({ cancelled: existed });
+    },
+    // eslint-disable-next-line unicorn/no-null -- Scheduler.get returns null when absent (public API contract)
+    get: (id) => Promise.resolve(pending.get(id) ?? null),
+    list: () => Promise.resolve([...pending.values()]),
+    runAfter: (delayMs, functionPath, args) => {
+      const id = enqueue(nowMs + delayMs, functionPath, args);
+      return Promise.resolve(id);
+    },
+    runAt: (timestampMs, functionPath, args) => {
+      const id = enqueue(timestampMs, functionPath, args);
+      return Promise.resolve(id);
+    }
+  };
+  const dispatchJob = async (job) => {
+    pending.delete(job.id);
+    const registry = getFunctionRegistry();
+    const entry = registry.get(job.functionPath);
+    if (entry === void 0) {
+      console.warn(`[fake-scheduler] unknown functionPath "${job.functionPath}" — job ${job.id} dropped`);
+      return;
+    }
+    if (entry.kind === "mutation" || entry.kind === "action") {
+      const dispatch = getDispatch();
+      const mutationContext = getMutationContext();
+      await dispatch(entry.kind, entry, mutationContext, job.args);
+    } else {
+      console.warn(
+        `[fake-scheduler] functionPath "${job.functionPath}" is a ${entry.kind} — only mutations and actions can be scheduled; job ${job.id} dropped`
+      );
+    }
+  };
+  const executeDue = async (cutoff) => {
+    const due = [...pending.values()].filter((j) => j.scheduledFor <= cutoff).toSorted((a, b) => a.scheduledFor - b.scheduledFor);
+    const failed = [];
+    for (const job of due) {
+      try {
+        await dispatchJob(job);
+      } catch (error) {
+        const failure = { args: job.args, error, functionPath: job.functionPath, id: job.id };
+        failed.push(failure);
+        recordedFailures.push(failure);
+      }
+    }
+    return { executed: due.length, failed };
+  };
+  const runSweep = async (cutoff, options) => {
+    const { executed, failed } = await executeDue(cutoff);
+    if (failed.length > 0 && (options?.throwOnError ?? true)) {
+      const [first] = failed;
+      if (failed.length === 1 && first !== void 0) {
+        throw first.error;
+      }
+      throw new AggregateError(
+        failed.map((f) => f.error),
+        `${String(failed.length)} scheduled jobs failed: ${failed.map((f) => f.functionPath).join(", ")}`
+      );
+    }
+    return executed;
+  };
+  const controls = {
+    advance: (ms, options) => {
+      nowMs += ms;
+      return runSweep(nowMs, options);
+    },
+    failures: () => [...recordedFailures],
+    list: () => [...pending.values()],
+    runPending: (options) => runSweep(Number.POSITIVE_INFINITY, options)
+  };
+  return { controls, scheduler };
+};
+
+const createSqlExec = () => {
+  const database = new DatabaseSync(":memory:");
+  const cursor = (rows) => {
+    return {
+      one() {
+        if (rows.length !== 1) {
+          throw new Error(`expected exactly one row, received ${String(rows.length)}`);
+        }
+        const [only] = rows;
+        return only;
+      },
+      [Symbol.iterator]() {
+        return rows[Symbol.iterator]();
+      },
+      toArray() {
+        return rows;
+      }
+    };
+  };
+  const run = (query, ...params) => {
+    const statement = database.prepare(query);
+    const rows = statement.all(...params);
+    return cursor(rows);
+  };
+  return {
+    close: () => {
+      database.close();
+    },
+    sql: { exec: run }
+  };
+};
+
+const registeredFunctionKind = (value) => {
+  if (typeof value !== "object" || value === null) {
+    return void 0;
+  }
+  const { kind } = value;
+  if (kind === "query" || kind === "mutation" || kind === "action") {
+    return kind;
+  }
+  return void 0;
+};
+const registeredFunctionVisibility = (value) => typeof value === "object" && value !== null && value.visibility === "internal" ? "internal" : "public";
+const unavailable = (surface) => {
+  throw new Error(`ctx.${surface} is not available in the in-memory @lunora/testing harness (v1)`);
+};
+const stubProxy = (surface) => /* @__PURE__ */ new Proxy((..._args) => unavailable(surface), {
+  apply: () => unavailable(surface),
+  get: () => unavailable(surface)
+});
+const noopLog = {
+  debug: () => void 0,
+  error: () => void 0,
+  info: () => void 0,
+  log: () => void 0,
+  warn: () => void 0
+};
+const buildSubscribe = (runRegistered, queryContext, mutationListeners) => {
+  const factory = (referenceOrInline, args) => {
+    let done = false;
+    let pendingResolve;
+    let pendingResult;
+    let latestSeq = 0;
+    let appliedSeq = 0;
+    const runQuery = () => {
+      if (registeredFunctionKind(referenceOrInline)) {
+        return runRegistered("query", referenceOrInline, queryContext, args, false);
+      }
+      return Promise.resolve(referenceOrInline(queryContext));
+    };
+    const emit = (seq, value) => {
+      if (seq < appliedSeq) {
+        return;
+      }
+      appliedSeq = seq;
+      const iterResult = { done: false, value };
+      if (pendingResolve === void 0) {
+        pendingResult = iterResult;
+      } else {
+        const resolve = pendingResolve;
+        pendingResolve = void 0;
+        pendingResult = void 0;
+        resolve(iterResult);
+      }
+    };
+    const emitAt = (seq) => (value) => {
+      emit(seq, value);
+    };
+    const listener = () => {
+      if (done) {
+        return;
+      }
+      latestSeq += 1;
+      const seq = latestSeq;
+      runQuery().then(emitAt(seq)).catch(() => void 0);
+    };
+    mutationListeners.add(listener);
+    const iterator = {
+      [Symbol.asyncIterator]() {
+        return iterator;
+      },
+      next: () => {
+        if (done) {
+          return Promise.resolve({ done: true, value: void 0 });
+        }
+        if (pendingResult !== void 0 && appliedSeq === latestSeq) {
+          const result = pendingResult;
+          pendingResult = void 0;
+          return Promise.resolve(result);
+        }
+        if (appliedSeq < latestSeq) {
+          return new Promise((resolve) => {
+            pendingResolve = resolve;
+          });
+        }
+        return runQuery().then((value) => {
+          if (pendingResult !== void 0) {
+            const result = pendingResult;
+            pendingResult = void 0;
+            return result;
+          }
+          return { done: false, value };
+        });
+      },
+      return: () => {
+        done = true;
+        mutationListeners.delete(listener);
+        if (pendingResolve !== void 0) {
+          const resolve = pendingResolve;
+          pendingResolve = void 0;
+          resolve({ done: true, value: void 0 });
+        }
+        return Promise.resolve({ done: true, value: void 0 });
+      }
+    };
+    runQuery().then(emitAt(0)).catch(() => void 0);
+    return iterator;
+  };
+  return factory;
+};
+const lunoraTest = (schema, options) => {
+  const { close, sql } = createSqlExec();
+  const ddlSchema = schema;
+  runShardMigrations(sql, ddlSchema);
+  const database = createShardCtxDb({ schema: ddlSchema, sql });
+  const execStatement = (statement) => {
+    const runner = sql.exec;
+    runner.call(sql, statement);
+  };
+  let transactionDepth = 0;
+  const runInMutationTransaction = async (function_) => {
+    if (transactionDepth > 0) {
+      return function_();
+    }
+    transactionDepth = 1;
+    execStatement("BEGIN");
+    try {
+      const result = await function_();
+      execStatement("COMMIT");
+      return result;
+    } catch (error) {
+      try {
+        execStatement("ROLLBACK");
+      } catch {
+      }
+      throw error;
+    } finally {
+      transactionDepth = 0;
+    }
+  };
+  let closed = false;
+  const closeDatabase = () => {
+    if (closed) {
+      return;
+    }
+    closed = true;
+    close();
+  };
+  const functionRegistryMap = new Map(
+    Object.entries(options?.functions ?? {}).map(([path, function_]) => [path, function_])
+  );
+  const mutationListeners = /* @__PURE__ */ new Set();
+  const notifyMutationListeners = () => {
+    for (const listener of mutationListeners) {
+      listener();
+    }
+  };
+  let scheduledDispatchRef;
+  let mutationContextRef;
+  const { controls: schedulerControls, scheduler: fakeScheduler } = createFakeScheduler(
+    () => {
+      if (scheduledDispatchRef === void 0) {
+        throw new Error("[fake-scheduler] dispatch not yet available — scheduler.advance called before harness construction completed");
+      }
+      return scheduledDispatchRef;
+    },
+    () => {
+      if (mutationContextRef === void 0) {
+        throw new Error("[fake-scheduler] mutationContext not yet available — scheduler.advance called before harness construction completed");
+      }
+      return mutationContextRef;
+    },
+    () => functionRegistryMap
+  );
+  const makeHarness = (identity) => {
+    const auth = {
+      // eslint-disable-next-line unicorn/no-null -- AuthState.getIdentity's anonymous sentinel is `null` (mirrors a decoded JWT being absent)
+      getIdentity: () => Promise.resolve(identity ?? null),
+      // eslint-disable-next-line unicorn/no-null -- AuthState.userId's anonymous sentinel is `null`
+      userId: identity?.userId ?? null
+    };
+    const queryContext = {
+      auth,
+      db: database,
+      log: noopLog,
+      // eslint-disable-next-line @typescript-eslint/no-use-before-define -- lazy closure: `runInternal` is invoked only when a handler calls ctx.runQuery, after construction completes
+      runQuery: (reference, args) => runInternal("query", reference, queryContext, args),
+      storage: stubProxy("storage"),
+      vectors: stubProxy("vectors")
+    };
+    const mutationContext = {
+      auth,
+      db: database,
+      log: noopLog,
+      // eslint-disable-next-line @typescript-eslint/no-use-before-define -- lazy closure: `runInternal` is invoked only when a handler calls ctx.runMutation, after construction completes
+      runMutation: (reference, args) => runInternal("mutation", reference, mutationContext, args),
+      // eslint-disable-next-line @typescript-eslint/no-use-before-define -- lazy closure: `runInternal` is invoked only when a handler calls ctx.runQuery, after construction completes
+      runQuery: (reference, args) => runInternal("query", reference, queryContext, args),
+      scheduler: fakeScheduler,
+      storage: stubProxy("storage"),
+      vectors: stubProxy("vectors"),
+      workflows: stubProxy("workflows")
+    };
+    mutationContextRef ??= mutationContext;
+    const actionContext = {
+      auth,
+      db: database,
+      // Use the injected fetch when provided; fall back to the v1 stub otherwise.
+      fetch: options?.fetch ?? stubProxy("fetch"),
+      log: noopLog,
+      // eslint-disable-next-line @typescript-eslint/no-use-before-define -- lazy closure: `runInternal` is invoked only when a handler calls ctx.runAction, after construction completes
+      runAction: (reference, args) => runInternal("action", reference, actionContext, args),
+      // eslint-disable-next-line @typescript-eslint/no-use-before-define -- lazy closure: `runInternal` is invoked only when a handler calls ctx.runMutation, after construction completes
+      runMutation: (reference, args) => runInternal("mutation", reference, mutationContext, args),
+      // eslint-disable-next-line @typescript-eslint/no-use-before-define -- lazy closure: `runInternal` is invoked only when a handler calls ctx.runQuery, after construction completes
+      runQuery: (reference, args) => runInternal("query", reference, queryContext, args),
+      scheduler: fakeScheduler,
+      storage: stubProxy("storage"),
+      vectors: stubProxy("vectors"),
+      workflows: stubProxy("workflows")
+    };
+    const runRegistered = (expected, reference, context, args, allowInternal) => {
+      const kind = registeredFunctionKind(reference);
+      if (kind !== expected) {
+        throw new Error(`expected a registered ${expected}, received a ${kind ?? "non-function"} reference`);
+      }
+      if (!allowInternal && registeredFunctionVisibility(reference) === "internal") {
+        throw new Error(
+          `"${expected}" is an internal function — it is unreachable from the external RPC boundary in production. Call it through ctx.run${expected.charAt(0).toUpperCase()}${expected.slice(1)} from another function instead.`
+        );
+      }
+      return Promise.resolve(reference.handler(context, args ?? {}));
+    };
+    const runInternal = (expected, reference, context, args) => runRegistered(expected, reference, context, args, true);
+    scheduledDispatchRef ??= (kind, reference, context, args) => {
+      if (kind === "mutation") {
+        return runInMutationTransaction(() => runRegistered("mutation", reference, context, args, true)).then((result) => {
+          notifyMutationListeners();
+          return result;
+        });
+      }
+      return runInternal("action", reference, context, args);
+    };
+    const query = ((referenceOrInline, args) => {
+      if (registeredFunctionKind(referenceOrInline)) {
+        return runRegistered("query", referenceOrInline, queryContext, args, false);
+      }
+      return Promise.resolve(referenceOrInline(queryContext));
+    });
+    const mutation = ((referenceOrInline, args) => {
+      if (registeredFunctionKind(referenceOrInline)) {
+        return runInMutationTransaction(() => runRegistered("mutation", referenceOrInline, mutationContext, args, false)).then((result) => {
+          notifyMutationListeners();
+          return result;
+        });
+      }
+      return runInMutationTransaction(() => referenceOrInline(mutationContext)).then((result) => {
+        notifyMutationListeners();
+        return result;
+      });
+    });
+    const action = ((referenceOrInline, args) => {
+      if (registeredFunctionKind(referenceOrInline)) {
+        return runRegistered("action", referenceOrInline, actionContext, args, false);
+      }
+      return Promise.resolve(referenceOrInline(actionContext));
+    });
+    const subscribe = buildSubscribe(runRegistered, queryContext, mutationListeners);
+    const harness = {
+      action,
+      close: closeDatabase,
+      mutation,
+      query,
+      run: (function_) => runInMutationTransaction(() => function_(mutationContext)).then((result) => {
+        notifyMutationListeners();
+        return result;
+      }),
+      scheduler: schedulerControls,
+      subscribe,
+      // A scoped view shares the SAME sql/db handle (created once above), so
+      // writes performed under an identity persist for every accessor.
+      withIdentity: (next) => makeHarness(next)
+    };
+    return harness;
+  };
+  return makeHarness(null);
+};
+
+export { lunoraTest };

package/package.json

@@ -1,31 +1,56 @@
 {
   "name": "@lunora/testing",
-  "version": "0.0.0",
+  "version": "1.0.0-alpha.2",
   "description": "Testing toolkit for Lunora: an in-memory harness for queries, mutations, and actions",
-  "license": "FSL-1.1-Apache-2.0",
+  "keywords": [
+    "cloudflare",
+    "durable-objects",
+    "e2e",
+    "lunora",
+    "mail",
+    "playwright",
+    "testing",
+    "workers"
+  ],
   "homepage": "https://lunora.sh",
+  "bugs": "https://github.com/anolilab/lunora/issues",
+  "license": "FSL-1.1-Apache-2.0",
+  "author": {
+    "name": "Daniel Bannert",
+    "email": "d.bannert@anolilab.de"
+  },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/anolilab/lunora.git",
     "directory": "packages/testing"
   },
-  "bugs": {
-    "url": "https://github.com/anolilab/lunora/issues"
-  },
-  "keywords": [
-    "lunora",
-    "cloudflare",
-    "workers",
-    "durable-objects",
-    "testing",
-    "e2e",
-    "mail",
-    "playwright"
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE.md",
+    "__assets__"
   ],
+  "type": "module",
+  "sideEffects": false,
+  "main": "./dist/index.mjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs"
+    },
+    "./package.json": "./package.json"
+  },
   "publishConfig": {
     "access": "public"
   },
-  "files": [
-    "README.md"
-  ]
+  "dependencies": {
+    "@lunora/do": "1.0.0-alpha.2",
+    "@lunora/mail": "1.0.0-alpha.1",
+    "@lunora/server": "1.0.0-alpha.1"
+  },
+  "engines": {
+    "node": "^22.15.0 || >=24.11.0"
+  }
 }