@elench/testkit 0.1.85 → 0.1.87

package/lib/runtime-src/shared/fixture-engine.mjs

@@ -0,0 +1,320 @@
+const DEFAULT_SLUG_MAX_LENGTH = 63;
+const DEFAULT_STRING_SUFFIX_LENGTH = 12;
+const DEFAULT_TOKEN_SUFFIX_LENGTH = 16;
+const DEFAULT_EMAIL_DOMAIN = "example.test";
+const STACK_LOCATION_PATTERN = /(file:\/\/[^\s)]+|\/[^\s):]+):(\d+):(\d+)/;
+
+export function createFixtureScope({ namespace, locationSkips = [] } = {}) {
+  const normalizedNamespace = normalizeNamespace(namespace);
+  const entries = new Map();
+  const creationOrder = [];
+  const activeEntries = [];
+  const values = createFixtureValues(normalizedNamespace);
+  const skipMatchers = [
+    "/runtime-src/shared/fixture-engine.mjs",
+    "/runtime-src/k6/dal-fixtures.js",
+    ...locationSkips,
+  ].filter(Boolean);
+
+  function seed(kind, key, signature, create) {
+    const normalizedKind = normalizeRequiredString(kind, "fixture kind");
+    const normalizedKey = normalizeRequiredString(key, "fixture key");
+    if (typeof create !== "function") {
+      throw new Error(
+        `Fixture ${formatFixtureRef(normalizedKind, normalizedKey)} requires a synchronous create callback.`
+      );
+    }
+
+    const entryId = buildEntryId(normalizedKind, normalizedKey);
+    const parentEntry = activeEntries[activeEntries.length - 1] || null;
+    if (parentEntry) {
+      parentEntry.dependencies.add(entryId);
+    }
+
+    const normalizedSignature = normalizeJsonValue(signature);
+    const signatureJson = stableJsonStringify(normalizedSignature);
+    const existing = entries.get(entryId);
+    if (existing) {
+      if (existing.state === "creating") {
+        throw new Error(formatFixtureCycleError(existing, activeEntries, normalizedKind, normalizedKey));
+      }
+
+      if (existing.signatureJson !== signatureJson) {
+        throw new Error(
+          formatFixtureConflictError(existing, normalizedSignature, signatureJson)
+        );
+      }
+
+      existing.reuseCount += 1;
+      return existing.result;
+    }
+
+    const entry = {
+      entryId,
+      kind: normalizedKind,
+      key: normalizedKey,
+      state: "creating",
+      signature: normalizedSignature,
+      signatureJson,
+      location: captureCallsite(skipMatchers),
+      dependencies: new Set(),
+      reuseCount: 0,
+      order: creationOrder.length + 1,
+      result: undefined,
+    };
+
+    entries.set(entryId, entry);
+    creationOrder.push(entryId);
+    activeEntries.push(entry);
+
+    try {
+      const result = create();
+      if (result && typeof result.then === "function") {
+        throw new Error(
+          `Fixture ${formatFixtureRef(normalizedKind, normalizedKey)} returned a Promise. DAL fixtures must be synchronous.`
+        );
+      }
+      entry.state = "ready";
+      entry.result = result;
+      return result;
+    } catch (error) {
+      entries.delete(entryId);
+      creationOrder.pop();
+      throw error;
+    } finally {
+      activeEntries.pop();
+    }
+  }
+
+  function records() {
+    return creationOrder
+      .map((entryId) => entries.get(entryId))
+      .filter(Boolean)
+      .map((entry) => ({
+        kind: entry.kind,
+        key: entry.key,
+        signature: cloneJsonValue(entry.signature),
+        reuseCount: entry.reuseCount,
+        order: entry.order,
+        dependencies: [...entry.dependencies]
+          .map((dependencyId) => entries.get(dependencyId))
+          .filter(Boolean)
+          .map((dependency) => ({
+            kind: dependency.kind,
+            key: dependency.key,
+          })),
+        ...(entry.location ? { location: { ...entry.location } } : {}),
+      }));
+  }
+
+  return {
+    namespace: normalizedNamespace,
+    values,
+    id: values.uuid,
+    uuid: values.uuid,
+    slug: values.slug,
+    email: values.email,
+    string: values.string,
+    token: values.token,
+    seed,
+    records,
+  };
+}
+
+export function createFixtureValues(namespace) {
+  const normalizedNamespace = normalizeNamespace(namespace);
+
+  function uuid(label) {
+    const hex = namespacedHex(normalizedNamespace, label).slice(0, 32).split("");
+    hex[12] = "4";
+    hex[16] = ((Number.parseInt(hex[16] || "0", 16) & 0x3) | 0x8).toString(16);
+    return `${hex.slice(0, 8).join("")}-${hex.slice(8, 12).join("")}-${hex.slice(12, 16).join("")}-${hex.slice(16, 20).join("")}-${hex.slice(20, 32).join("")}`;
+  }
+
+  function slug(label, options = {}) {
+    const fallback = normalizeToken(options.fallback) || "resource";
+    const base = normalizeToken(label) || fallback;
+    const maxLength = normalizePositiveInteger(options.maxLength) || DEFAULT_SLUG_MAX_LENGTH;
+    return `${base}-${namespacedSuffix(normalizedNamespace, `slug:${label}`, DEFAULT_STRING_SUFFIX_LENGTH)}`.slice(
+      0,
+      maxLength
+    );
+  }
+
+  function email(label, options = {}) {
+    const fallback = normalizeToken(options.fallback) || "user";
+    const base = normalizeToken(label) || fallback;
+    const domain = normalizeEmailDomain(options.domain) || DEFAULT_EMAIL_DOMAIN;
+    const suffixLength =
+      normalizePositiveInteger(options.suffixLength) || DEFAULT_STRING_SUFFIX_LENGTH;
+    return `${base}-${namespacedSuffix(normalizedNamespace, `email:${label}`, suffixLength)}@${domain}`;
+  }
+
+  function string(label, options = {}) {
+    const fallback = normalizeToken(options.fallback) || "value";
+    const prefix = normalizeToken(options.prefix) || normalizeToken(label) || fallback;
+    const suffixLength =
+      normalizePositiveInteger(options.suffixLength) || DEFAULT_STRING_SUFFIX_LENGTH;
+    const maxLength = normalizePositiveInteger(options.maxLength) || null;
+    const value = `${prefix}-${namespacedSuffix(normalizedNamespace, `string:${label}:${prefix}`, suffixLength)}`;
+    return maxLength ? value.slice(0, maxLength) : value;
+  }
+
+  function token(label, options = {}) {
+    return string(label, {
+      ...options,
+      fallback: options.fallback || "token",
+      suffixLength: normalizePositiveInteger(options.suffixLength) || DEFAULT_TOKEN_SUFFIX_LENGTH,
+    });
+  }
+
+  return {
+    uuid,
+    slug,
+    email,
+    string,
+    token,
+  };
+}
+
+function formatFixtureConflictError(existing, nextSignature, nextSignatureJson) {
+  const location = existing.location ? ` First declared at ${formatLocation(existing.location)}.` : "";
+  return [
+    `Fixture ${formatFixtureRef(existing.kind, existing.key)} was seeded twice with conflicting signatures.`,
+    location,
+    ` Existing: ${existing.signatureJson}`,
+    ` New: ${nextSignatureJson || stableJsonStringify(normalizeJsonValue(nextSignature))}`,
+  ].join("");
+}
+
+function formatFixtureCycleError(existing, activeEntries, kind, key) {
+  const cycleStartIndex = activeEntries.findIndex((entry) => entry.entryId === existing.entryId);
+  const cycleEntries = cycleStartIndex >= 0 ? activeEntries.slice(cycleStartIndex) : activeEntries;
+  const chain = [...cycleEntries.map((entry) => formatFixtureRef(entry.kind, entry.key)), formatFixtureRef(kind, key)];
+  return `Fixture dependency cycle detected: ${chain.join(" -> ")}.`;
+}
+
+function formatFixtureRef(kind, key) {
+  return `${kind}:${key}`;
+}
+
+function formatLocation(location) {
+  return `${location.path}:${location.line}:${location.column}`;
+}
+
+function buildEntryId(kind, key) {
+  return `${kind}::${key}`;
+}
+
+function normalizeNamespace(namespace) {
+  return normalizeToken(namespace) || "standalone";
+}
+
+function normalizeRequiredString(value, label) {
+  const normalized = String(value || "").trim();
+  if (normalized.length === 0) {
+    throw new Error(`Fixture ${label} must be a non-empty string.`);
+  }
+  return normalized;
+}
+
+function normalizePositiveInteger(value) {
+  if (!Number.isInteger(value) || value <= 0) return null;
+  return value;
+}
+
+function normalizeEmailDomain(value) {
+  const normalized = String(value || "").trim().toLowerCase();
+  return normalized.length > 0 ? normalized : null;
+}
+
+function normalizeToken(value) {
+  return String(value || "")
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-+|-+$/g, "");
+}
+
+function hash32(input) {
+  let hash = 0x811c9dc5;
+  for (let index = 0; index < input.length; index += 1) {
+    hash ^= input.charCodeAt(index);
+    hash = Math.imul(hash, 0x01000193) >>> 0;
+  }
+  return hash.toString(16).padStart(8, "0");
+}
+
+function namespacedHex(namespace, label) {
+  return [0, 1, 2, 3].map((part) => hash32(`${namespace}:${label}:${part}`)).join("");
+}
+
+function namespacedSuffix(namespace, label, length) {
+  return namespacedHex(namespace, label).slice(0, length);
+}
+
+function captureCallsite(skipMatchers) {
+  const stack = new Error().stack;
+  if (!stack) return null;
+
+  for (const line of stack.split("\n").slice(1)) {
+    const match = line.match(STACK_LOCATION_PATTERN);
+    if (!match) continue;
+    const [rawPath, rawLine, rawColumn] = match.slice(1);
+    if (!rawPath || !rawLine || !rawColumn) continue;
+    const path = normalizeStackPath(rawPath);
+    if (skipMatchers.some((matcher) => path.endsWith(matcher) || path.includes(matcher))) {
+      continue;
+    }
+    return {
+      path,
+      line: Number(rawLine),
+      column: Number(rawColumn),
+    };
+  }
+
+  return null;
+}
+
+function normalizeStackPath(rawPath) {
+  return String(rawPath || "").replace(/^file:\/\//, "");
+}
+
+function stableJsonStringify(value) {
+  return JSON.stringify(normalizeJsonValue(value));
+}
+
+function cloneJsonValue(value) {
+  return normalizeJsonValue(value);
+}
+
+function normalizeJsonValue(value) {
+  if (
+    value === null ||
+    value === undefined ||
+    typeof value === "boolean" ||
+    typeof value === "number" ||
+    typeof value === "string"
+  ) {
+    return value;
+  }
+
+  if (typeof value === "bigint") {
+    return value.toString();
+  }
+
+  if (Array.isArray(value)) {
+    return value.map((entry) => normalizeJsonValue(entry));
+  }
+
+  if (typeof value === "object") {
+    return Object.keys(value)
+      .sort()
+      .reduce((result, key) => {
+        result[key] = normalizeJsonValue(value[key]);
+        return result;
+      }, {});
+  }
+
+  return String(value);
+}

package/node_modules/@elench/next-analysis/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elench/next-analysis",
-  "version": "0.1.85",
+  "version": "0.1.87",
   "description": "SWC-backed Next.js source analysis primitives for Erench tools",
   "type": "module",
   "exports": {

package/node_modules/@elench/testkit-bridge/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elench/testkit-bridge",
-  "version": "0.1.85",
+  "version": "0.1.87",
   "description": "Browser bridge helpers for testkit",
   "type": "module",
   "main": "./dist/index.js",
@@ -22,7 +22,7 @@
     "typecheck": "tsc -p tsconfig.json --noEmit"
   },
   "dependencies": {
-    "@elench/testkit-protocol": "0.1.85"
+    "@elench/testkit-protocol": "0.1.87"
   },
   "private": false
 }

package/node_modules/@elench/testkit-protocol/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elench/testkit-protocol",
-  "version": "0.1.85",
+  "version": "0.1.87",
   "description": "Shared browser protocol for testkit bridge and extension consumers",
   "type": "module",
   "main": "./dist/index.js",

package/node_modules/@elench/ts-analysis/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elench/ts-analysis",
-  "version": "0.1.85",
+  "version": "0.1.87",
   "description": "TypeScript compiler-backed source analysis primitives for Erench tools",
   "type": "module",
   "exports": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elench/testkit",
-  "version": "0.1.85",
+  "version": "0.1.87",
   "description": "CLI for discovering and running local HTTP, DAL, and Playwright test suites",
   "type": "module",
   "workspaces": [
@@ -82,10 +82,10 @@
   },
   "dependencies": {
     "@babel/code-frame": "^7.29.0",
-    "@elench/next-analysis": "0.1.85",
-    "@elench/testkit-bridge": "0.1.85",
-    "@elench/testkit-protocol": "0.1.85",
-    "@elench/ts-analysis": "0.1.85",
+    "@elench/next-analysis": "0.1.87",
+    "@elench/testkit-bridge": "0.1.87",
+    "@elench/testkit-protocol": "0.1.87",
+    "@elench/ts-analysis": "0.1.87",
     "@oclif/core": "^4.10.6",
     "esbuild": "^0.25.11",
     "execa": "^9.5.0",

package/lib/cli/commands/artifacts.mjs

@@ -1,45 +0,0 @@
-import { Args, Command } from "@oclif/core";
-import { sharedFlags } from "../command-helpers.mjs";
-import { collectArtifactEntries, loadCurrentRunArtifact } from "../viewer.mjs";
-
-export default class ArtifactsCommand extends Command {
-  static summary = "List persisted artifacts from the latest run";
-
-  static enableJsonFlag = true;
-
-  static args = {
-    file: Args.string({
-      description: "Optional file path to filter artifacts",
-      required: false,
-    }),
-  };
-
-  static flags = sharedFlags;
-
-  async run() {
-    const { args, flags } = await this.parse(ArtifactsCommand);
-    const productDir = flags.dir || process.cwd();
-    const runArtifact = loadCurrentRunArtifact(productDir);
-    const entries = collectArtifactEntries(productDir, runArtifact, args.file || null, flags.service || null)
-      .map((entry) => ({
-        service: entry.service.name,
-        suite: `${entry.suite.type}:${entry.suite.name}`,
-        file: entry.file.path,
-        name: entry.artifactRef.name,
-        kind: entry.artifactRef.kind,
-        summary: entry.artifactRef.summary,
-        path: entry.artifactRef.path,
-      }));
-
-    if (!this.jsonEnabled()) {
-      for (const entry of entries) {
-        this.log(`${entry.file}`);
-        this.log(`  ${entry.name}${entry.kind ? ` [${entry.kind}]` : ""}`);
-        if (entry.summary) this.log(`    ${entry.summary}`);
-        this.log(`    ${entry.path}`);
-      }
-    }
-
-    return entries;
-  }
-}

package/lib/cli/commands/logs.mjs

@@ -1,47 +0,0 @@
-import { Args, Command, Flags } from "@oclif/core";
-import { sharedFlags } from "../command-helpers.mjs";
-import { readLogTail } from "../../runner/logs.mjs";
-import { getServiceLogRefs, loadCurrentRunArtifact, resolveFileSubject } from "../viewer.mjs";
-import path from "path";
-
-export default class LogsCommand extends Command {
-  static summary = "Show backend log tails relevant to one file from the latest run";
-
-  static enableJsonFlag = true;
-
-  static args = {
-    file: Args.string({
-      description: "Optional file path; defaults to the first failed file",
-      required: false,
-    }),
-  };
-
-  static flags = {
-    ...sharedFlags,
-    tail: Flags.integer({
-      description: "Number of lines to show from each log",
-      default: 40,
-    }),
-  };
-
-  async run() {
-    const { args, flags } = await this.parse(LogsCommand);
-    const productDir = flags.dir || process.cwd();
-    const runArtifact = loadCurrentRunArtifact(productDir);
-    const subject = resolveFileSubject(runArtifact, args.file || null, flags.service || null);
-    const logs = getServiceLogRefs(runArtifact, subject.service.name).map((entry) => ({
-      ...entry,
-      lines: readLogTail(path.join(productDir, entry.path), flags.tail),
-    }));
-
-    if (!this.jsonEnabled()) {
-      for (const entry of logs) {
-        this.log(`${entry.runtimeLabel}`);
-        this.log(`  ${entry.path}`);
-        for (const line of entry.lines) this.log(`  ${line}`);
-      }
-    }
-
-    return logs;
-  }
-}

package/lib/cli/commands/show.mjs

@@ -1,47 +0,0 @@
-import { Args, Command, Flags } from "@oclif/core";
-import { sharedFlags } from "../command-helpers.mjs";
-import { formatFileDetail, loadCurrentRunArtifact, resolveFileSubject } from "../viewer.mjs";
-
-export default class ShowCommand extends Command {
-  static summary = "Show the most useful details for one file from the latest run";
-
-  static enableJsonFlag = true;
-
-  static args = {
-    file: Args.string({
-      description: "File path to inspect; defaults to the first failed file",
-      required: false,
-    }),
-  };
-
-  static flags = {
-    ...sharedFlags,
-    "log-tail": Flags.integer({
-      description: "Number of backend log lines to include",
-      default: 12,
-    }),
-  };
-
-  async run() {
-    const { args, flags } = await this.parse(ShowCommand);
-    const productDir = flags.dir || process.cwd();
-    const runArtifact = loadCurrentRunArtifact(productDir);
-    const subject = resolveFileSubject(runArtifact, args.file || null, flags.service || null);
-    const result = {
-      file: subject.file,
-      suite: {
-        name: subject.suite.name,
-        type: subject.suite.type,
-      },
-      service: {
-        name: subject.service.name,
-      },
-    };
-    if (!this.jsonEnabled()) {
-      for (const line of formatFileDetail(productDir, runArtifact, subject, { logTail: flags["log-tail"] })) {
-        this.log(line);
-      }
-    }
-    return result;
-  }
-}

package/lib/cli/commands/watch.mjs

@@ -1,23 +0,0 @@
-import React, { createElement } from "react";
-import { Command } from "@oclif/core";
-import { render } from "ink";
-import { sharedFlags } from "../command-helpers.mjs";
-import { WatchApp } from "../tui/watch-app.mjs";
-
-export default class WatchCommand extends Command {
-  static summary = "Open an interactive viewer for the latest run artifact";
-
-  static flags = sharedFlags;
-
-  async run() {
-    const { flags } = await this.parse(WatchCommand);
-    const productDir = flags.dir || process.cwd();
-    const app = render(
-      createElement(WatchApp, {
-        productDir,
-        serviceFilter: flags.service || null,
-      })
-    );
-    await app.waitUntilExit();
-  }
-}

package/lib/cli/tui/run-app.mjs

@@ -1 +0,0 @@
-export { RunSessionApp as RunApp } from "./run-session-app.mjs";