@cosmicdrift/kumiko-framework 0.328.0 → 0.328.1

package/src/engine/feature-ast/__tests__/parse-happy-path.test.ts

@@ -1,196 +0,0 @@
-// Happy-path roundtrip: a single feature file that exercises the
-// inline authoring contract end-to-end. Every r.* call here is the
-// shape AI-generated features will use + that the Designer will edit.
-//
-// Why this matters: real bundled-features (parse-real-features.test.ts)
-// fail many extractors because they use factories + identifier handlers.
-// That is fine for framework-internal code, but the AI Builder must
-// NEVER produce code with ParseErrors. This test pins the contract.
-
-import { describe, expect, test } from "bun:test";
-import { Project } from "ts-morph";
-import { parseSourceFile } from "../parse";
-
-const INLINE_FEATURE = `
-import { defineFeature } from "@cosmicdrift/kumiko-framework/engine";
-import { z } from "zod";
-
-defineFeature("todoList", (r) => {
-  r.requires("auth", "tenant");
-  r.toggleable({ default: true });
-
-  r.entity("task", {
-    fields: {
-      title: { type: "text", required: true, searchable: true },
-      done: { type: "boolean", default: false },
-      priority: { type: "select", options: ["low", "medium", "high"], default: "medium" },
-    },
-  });
-
-  r.relation("task", "owner", { kind: "belongsTo", to: "user" });
-
-  r.config({
-    keys: {
-      maxItems: { type: "number", default: 100 },
-    },
-  });
-
-  r.translations({
-    keys: {
-      en: { title: "Tasks", create: "Create task" },
-      de: { title: "Aufgaben", create: "Aufgabe anlegen" },
-    },
-  });
-
-  r.defineEvent("taskCompleted", z.object({ id: z.string() }), { piiFields: "none", version: 1 });
-
-  r.writeHandler(
-    "task:create",
-    z.object({ title: z.string(), priority: z.string().optional() }),
-    async (event, ctx) => {
-      return { isSuccess: true, data: { id: "x" } };
-    },
-    { access: { roles: ["user"] } },
-  );
-
-  r.writeHandler({
-    name: "task:complete",
-    schema: z.object({ id: z.string() }),
-    handler: async (event, ctx) => ({ isSuccess: true, data: {} }),
-    access: { roles: ["user"] },
-  });
-
-  r.queryHandler(
-    "task:list",
-    z.object({}),
-    async (q, ctx) => [],
-    { access: { openToAll: { reason: "test handler callable by any signed-in test user" } } },
-  );
-
-  r.hook("postSave", "task", async (event, ctx) => {
-    console.log("task saved");
-  });
-
-  r.hook("postDelete", { allOf: "task" }, async (event, ctx) => {
-    console.log("task deleted");
-  });
-
-  r.metric("requests", { type: "counter" });
-  r.secret("apiKey", { description: "Stripe API key" });
-  r.claimKey("teamId", { type: "string" });
-
-  r.referenceData(
-    "priorityLabel",
-    [
-      { id: "low", label: "Low" },
-      { id: "high", label: "High" },
-    ],
-    { upsertKey: "id" },
-  );
-
-  r.nav({ id: "tasks", label: "Tasks", screen: "todoList:screen:task-list" });
-
-  r.workspace({ id: "personal", label: "Personal" });
-
-  r.screen({
-    id: "task-list",
-    type: "entityList",
-    entity: "task",
-    columns: ["title", "priority", "done"],
-  });
-});
-`;
-
-describe("parseSourceFile against a complete inline-form feature", () => {
-  const project = new Project({
-    skipAddingFilesFromTsConfig: true,
-    skipFileDependencyResolution: true,
-    useInMemoryFileSystem: true,
-  });
-  const sourceFile = project.createSourceFile("inline-feature.ts", INLINE_FEATURE);
-  const result = parseSourceFile(sourceFile);
-
-  test("featureName is read correctly", () => {
-    expect(result.featureName).toBe("todoList");
-  });
-
-  test("zero ParseErrors — the inline contract is fully extractable", () => {
-    expect(result.errors).toEqual([]);
-  });
-
-  test("zero UnknownPatterns — every r.* call dispatched to a real extractor", () => {
-    const unknowns = result.patterns.filter((p) => p.kind === "unknown");
-    expect(unknowns).toEqual([]);
-  });
-
-  test("all expected pattern-kinds are present", () => {
-    const kinds: ReadonlySet<string> = new Set(result.patterns.map((p) => p.kind));
-    const expected: readonly string[] = [
-      "requires",
-      "toggleable",
-      "entity",
-      "relation",
-      "config",
-      "translations",
-      "defineEvent",
-      "writeHandler",
-      "queryHandler",
-      "hook",
-      "metric",
-      "secret",
-      "claimKey",
-      "referenceData",
-      "nav",
-      "workspace",
-      "screen",
-    ];
-    for (const e of expected) {
-      expect(kinds.has(e), `expected kind "${e}" to appear`).toBe(true);
-    }
-  });
-
-  test("both writeHandler authoring forms (inline + object) produce separate patterns", () => {
-    const writeHandlers = result.patterns.filter((p) => p.kind === "writeHandler");
-    expect(writeHandlers).toHaveLength(2);
-    const handlerNames = writeHandlers.map((p) => (p as { handlerName: string }).handlerName);
-    expect(handlerNames).toContain("task:create");
-    expect(handlerNames).toContain("task:complete");
-  });
-
-  test("AccessRule is extracted into the typed shape (roles vs openToAll)", () => {
-    const writeCreate = result.patterns.find(
-      (p) =>
-        p.kind === "writeHandler" && (p as { handlerName: string }).handlerName === "task:create",
-    );
-    expect(writeCreate).toMatchObject({
-      access: { roles: ["user"] },
-    });
-
-    const queryList = result.patterns.find((p) => p.kind === "queryHandler");
-    expect(queryList).toMatchObject({
-      access: { openToAll: { reason: "test handler callable by any signed-in test user" } },
-    });
-  });
-
-  test("SourceLocation roundtrips raw text for opaque bodies", () => {
-    const hook = result.patterns.find((p) => p.kind === "hook") as
-      | { fnBody: { raw: string } }
-      | undefined;
-    expect(hook?.fnBody.raw).toContain("task saved");
-
-    const writeCreate = result.patterns.find(
-      (p) =>
-        p.kind === "writeHandler" && (p as { handlerName: string }).handlerName === "task:create",
-    ) as { handlerBody: { raw: string }; schemaSource: { raw: string } } | undefined;
-    expect(writeCreate?.handlerBody.raw).toContain("isSuccess: true");
-    expect(writeCreate?.schemaSource.raw).toContain("z.object");
-  });
-
-  test("source order matches authoring order", () => {
-    const orderedKinds = result.patterns.map((p) => p.kind);
-    expect(orderedKinds[0]).toBe("requires");
-    expect(orderedKinds[1]).toBe("toggleable");
-    expect(orderedKinds[2]).toBe("entity");
-    expect(orderedKinds[3]).toBe("relation");
-  });
-});

package/src/engine/feature-ast/__tests__/parse-real-features.test.ts

@@ -1,138 +0,0 @@
-// Roundtrip tests against real Kumiko features. Stress-tests the
-// extractor coverage with the same `defineFeature` calls that ship in
-// bundled-features and the PublicStatus sample. Findings inform the
-// Designer/AI authoring contract.
-//
-// **Key finding from C1.4:** real-world features authored before the
-// AST visitor existed lean heavily on factory helpers (`createEntity`,
-// `defineWriteHandler` returned via const) and identifier-typed handler
-// arguments. Both are unreadable statically — readJsonLikeNode bails on
-// function-call expressions, and extractHandlerLike requires a string
-// literal name when used in inline form. Each surfaces a clean
-// ParseError, never a crash.
-//
-// **Authoring contract** the Designer + AI Builder will demand:
-//   - r.entity("name", { fields: { ... } })          ← inline literal
-//   - r.writeHandler("name", schema, async (e, c) => …, options?)
-//     OR r.writeHandler({ name: "name", schema, handler: async … })
-//   - same for r.queryHandler / r.job / r.notification: NO captured
-//     consts, NO factory wrappers around the definition
-//
-// bundled-features stay unchanged — they are framework-internal and
-// optimised for code reuse, not for design-time editability. AI-
-// generated features and Designer-authored features will follow the
-// inline contract by construction.
-
-import { describe, expect, test } from "bun:test";
-import { resolve } from "node:path";
-import { parseFeatureFile } from "../parse";
-import type { FeaturePattern } from "../patterns";
-
-const REPO_ROOT = resolve(__dirname, "../../../../../..");
-
-type RealFeature = {
-  readonly path: string;
-  readonly expectedFeatureName: string;
-  // Kinds the visitor recognises as proper patterns (the rest land as
-  // ParseError because of factory/identifier usage — see the test
-  // helper below).
-  readonly recognisedKinds: readonly FeaturePattern["kind"][];
-  // Method names that ParseError due to factory/identifier author style.
-  // Empty for features that are entirely inline (rare today).
-  readonly errorMethodNames: readonly string[];
-};
-
-const FEATURES: readonly RealFeature[] = [
-  {
-    path: "packages/bundled-features/src/tenant/feature.ts",
-    expectedFeatureName: "tenant",
-    // entity + config used to ParseError here: their definitions reference
-    // local consts/factory calls, which readDataLiteralNode now resolves
-    // to a raw-ref sentinel instead of bailing to undefined (#998).
-    recognisedKinds: [
-      "requires",
-      "systemScope",
-      "entity",
-      "config",
-      "writeHandler",
-      "queryHandler",
-    ],
-    errorMethodNames: [],
-  },
-  {
-    path: "packages/bundled-features/src/audit/feature.ts",
-    expectedFeatureName: "audit",
-    recognisedKinds: ["queryHandler"],
-    errorMethodNames: [],
-  },
-  {
-    path: "packages/bundled-features/src/sessions/feature.ts",
-    expectedFeatureName: "sessions",
-    recognisedKinds: ["hook", "writeHandler", "queryHandler", "job"],
-    errorMethodNames: ["storeTable"],
-  },
-  {
-    path: "packages/bundled-features/src/auth-email-password/feature.ts",
-    expectedFeatureName: "auth-email-password",
-    recognisedKinds: ["requires", "writeHandler"],
-    errorMethodNames: [],
-  },
-];
-
-describe("parseFeatureFile against real Kumiko features", () => {
-  for (const feature of FEATURES) {
-    test(`${feature.path}: featureName + recognised kinds + clean ParseErrors`, () => {
-      const result = parseFeatureFile(resolve(REPO_ROOT, feature.path));
-
-      // Always reads the feature name regardless of authoring style.
-      expect(result.featureName).toBe(feature.expectedFeatureName);
-
-      // Every kind we promised to extract for this feature shows up.
-      const observedKinds = new Set(result.patterns.map((p) => p.kind));
-      for (const expected of feature.recognisedKinds) {
-        expect(observedKinds.has(expected), `expected kind "${expected}" in ${feature.path}`).toBe(
-          true,
-        );
-      }
-
-      // Every method we know fails statically (factory/identifier
-      // authoring) shows up at least once in errors.
-      const errorMethods = new Set(result.errors.map((e) => e.methodName));
-      for (const expected of feature.errorMethodNames) {
-        expect(
-          errorMethods.has(expected),
-          `expected ParseError methodName "${expected}" in ${feature.path}`,
-        ).toBe(true);
-      }
-    });
-  }
-
-  test("aggregate: no UnknownPattern across real features (every r.* call is dispatched)", () => {
-    // If this fails, a new r.* API has been added without an extractor +
-    // dispatcher case. UnknownPattern is the catch-all signal — it's
-    // legal but means the Designer/AI cannot edit that call.
-    const allUnknowns: { feature: string; methodName: string }[] = [];
-    for (const feature of FEATURES) {
-      const result = parseFeatureFile(resolve(REPO_ROOT, feature.path));
-      for (const pattern of result.patterns) {
-        if (pattern.kind === "unknown") {
-          allUnknowns.push({ feature: feature.path, methodName: pattern.methodName });
-        }
-      }
-    }
-    expect(allUnknowns).toEqual([]);
-  });
-
-  test("aggregate: every ParseError carries methodName + non-empty reason + source location", () => {
-    for (const feature of FEATURES) {
-      const result = parseFeatureFile(resolve(REPO_ROOT, feature.path));
-      for (const error of result.errors) {
-        expect(error.methodName).toMatch(/^[a-zA-Z]+$/);
-        expect(error.reason.length).toBeGreaterThan(10);
-        expect(error.source.file as string).toContain(feature.path.split("/").pop()!);
-        expect(error.source.start.line).toBeGreaterThan(0);
-        expect(error.source.raw).toContain("r.");
-      }
-    }
-  });
-});