@akanjs/devkit 2.3.11-rc.1 → 2.3.11-rc.10

package/workflow/executor.ts

@@ -403,6 +403,8 @@ export const createWorkflowStepRegistry = ({
   createUi,
   addField,
   addEnumField,
+  addMutation,
+  addSlice,
 }: WorkflowPrimitiveOperations): WorkflowStepRegistry => {
   const inspect = async () => undefined;
   const commandOnly = async () => undefined;
@@ -483,6 +485,24 @@ export const createWorkflowStepRegistry = ({
       ),
     [workflowStepKey("add-enum-field", "update-dictionary")]: inspect,
     [workflowStepKey("add-enum-field", "update-option")]: inspect,
+    [workflowStepKey("add-mutation", "update-service")]: async (_step, plan) =>
+      primitiveReportToWorkflowStepResult(
+        await addMutation({
+          app: workflowStringInput(plan.inputs.app),
+          module: workflowStringInput(plan.inputs.module),
+          mutation: workflowStringInput(plan.inputs.mutation),
+        }),
+      ),
+    [workflowStepKey("add-mutation", "update-signal")]: inspect,
+    [workflowStepKey("add-slice", "update-service-query")]: async (_step, plan) =>
+      primitiveReportToWorkflowStepResult(
+        await addSlice({
+          app: workflowStringInput(plan.inputs.app),
+          module: workflowStringInput(plan.inputs.module),
+          slice: workflowStringInput(plan.inputs.slice),
+        }),
+      ),
+    [workflowStepKey("add-slice", "update-signal-slice")]: inspect,
   };
 };
 

package/workflow/source.test.ts

@@ -1,5 +1,12 @@
 import { describe, expect, test } from "bun:test";
-import { inspectDictionaryStructure } from "./source";
+import {
+  hasClassMethod,
+  hasSignalFactoryEntry,
+  hasSourceParseErrors,
+  insertClassMethod,
+  insertSignalFactoryEntry,
+  inspectDictionaryStructure,
+} from "./source";
 
 describe("inspectDictionaryStructure", () => {
   test("preserves protected dictionary chain order around the model object", () => {
@@ -60,3 +67,109 @@ export const dictionary = modelDictionary(["en", "ko"])
     expect(structure.chainMethods).toEqual(["modelDictionary", "slice", "model", "translate", "error"]);
   });
 });
+
+describe("insertClassMethod", () => {
+  test("inserts a method into an empty service class body", () => {
+    const content = `import { serve } from "akanjs/service";
+import * as db from "../db";
+export class BannerService extends serve(db.banner, () => ({})) {}
+`;
+    const next = insertClassMethod(content, "BannerService", "  async archive() {\n    return true;\n  }");
+    expect(next).not.toBeNull();
+    expect(hasSourceParseErrors(next as string, "service.ts")).toBe(false);
+    expect(hasClassMethod(next as string, "BannerService", "archive")).toBe(true);
+  });
+
+  test("inserts a method into a populated service class body", () => {
+    const content = `import { serve } from "akanjs/service";
+import * as db from "../db";
+export class NotificationService extends serve(db.notification, () => ({})) {
+  async subscribe(token: string) {
+    return token;
+  }
+}
+`;
+    const next = insertClassMethod(content, "NotificationService", "  async archive() {\n    return true;\n  }");
+    expect(next).not.toBeNull();
+    expect(hasSourceParseErrors(next as string, "service.ts")).toBe(false);
+    expect(hasClassMethod(next as string, "NotificationService", "archive")).toBe(true);
+    expect(hasClassMethod(next as string, "NotificationService", "subscribe")).toBe(true);
+  });
+
+  test("returns null when the class is not found", () => {
+    expect(insertClassMethod("export class Other {}", "MissingService", "  x() {}")).toBeNull();
+  });
+});
+
+describe("insertSignalFactoryEntry", () => {
+  const mutationEntry =
+    "archive: mutation(Boolean)\n    .exec(async function () {\n      return await this.bannerService.archive();\n    }),";
+
+  test("adds mutation param when the endpoint factory has no params", () => {
+    const content = `import { endpoint } from "akanjs/signal";
+import * as srv from "../srv";
+export class BannerEndpoint extends endpoint(srv.banner, () => ({})) {}
+`;
+    const next = insertSignalFactoryEntry(content, "BannerEndpoint", "archive", mutationEntry, {
+      mode: "destructure",
+      name: "mutation",
+    });
+    expect(next).not.toBeNull();
+    expect(hasSourceParseErrors(next as string, "signal.ts")).toBe(false);
+    expect(hasSignalFactoryEntry(next as string, "BannerEndpoint", "archive")).toBe(true);
+    expect(next as string).toContain("{ mutation }");
+  });
+
+  test("extends an existing destructured param without dropping siblings", () => {
+    const content = `import { endpoint } from "akanjs/signal";
+import * as srv from "../srv";
+export class BannerEndpoint extends endpoint(srv.banner, ({ pubsub, query }) => ({
+  existing: query(String).exec(async function () {
+    return "x";
+  }),
+})) {}
+`;
+    const next = insertSignalFactoryEntry(content, "BannerEndpoint", "archive", mutationEntry, {
+      mode: "destructure",
+      name: "mutation",
+    });
+    expect(next).not.toBeNull();
+    expect(hasSourceParseErrors(next as string, "signal.ts")).toBe(false);
+    expect(next as string).toContain("{ pubsub, query, mutation }");
+    expect(hasSignalFactoryEntry(next as string, "BannerEndpoint", "archive")).toBe(true);
+    expect(hasSignalFactoryEntry(next as string, "BannerEndpoint", "existing")).toBe(true);
+  });
+
+  test("adds the init param to a slice factory and inserts the slice entry", () => {
+    const content = `import { slice, Admin, Public } from "akanjs/signal";
+import * as srv from "../srv";
+export class BannerSlice extends slice(srv.banner, { guards: { root: Admin, get: Public, cru: Admin } }, () => ({})) {}
+`;
+    const sliceEntry =
+      "inPublic: init()\n    .exec(function () {\n      return this.bannerService.queryInPublic();\n    }),";
+    const next = insertSignalFactoryEntry(content, "BannerSlice", "inPublic", sliceEntry, {
+      mode: "positional",
+      name: "init",
+    });
+    expect(next).not.toBeNull();
+    expect(hasSourceParseErrors(next as string, "signal.ts")).toBe(false);
+    expect(next as string).toContain("(init) =>");
+    expect(hasSignalFactoryEntry(next as string, "BannerSlice", "inPublic")).toBe(true);
+  });
+
+  test("is idempotent when the entry already exists", () => {
+    const content = `import { endpoint } from "akanjs/signal";
+import * as srv from "../srv";
+export class BannerEndpoint extends endpoint(srv.banner, ({ mutation }) => ({
+  archive: mutation(Boolean).exec(async function () {
+    return true;
+  }),
+})) {}
+`;
+    const next = insertSignalFactoryEntry(content, "BannerEndpoint", "archive", mutationEntry, {
+      mode: "destructure",
+      name: "mutation",
+    });
+    expect(next).toBe(content);
+  });
+});

package/workflow/source.ts

@@ -862,3 +862,134 @@ export const parseValues = (value: string | null) =>
     ?.split(",")
     .map((item) => item.trim())
     .filter(Boolean) ?? [];
+
+// ---- Service / signal insertion (add-mutation, add-slice) ----
+
+export const hasSourceParseErrors = (content: string, fileName = "source.ts") =>
+  hasParseDiagnostics(sourceFileFor(fileName, content));
+
+const findClassDeclaration = (source: ts.SourceFile, className: string): ts.ClassDeclaration | null => {
+  let found: ts.ClassDeclaration | null = null;
+  const visit = (node: ts.Node) => {
+    if (found) return;
+    if (ts.isClassDeclaration(node) && node.name?.text === className) {
+      found = node;
+      return;
+    }
+    ts.forEachChild(node, visit);
+  };
+  ts.forEachChild(source, visit);
+  return found;
+};
+
+const firstHeritageCall = (node: ts.ClassDeclaration): ts.CallExpression | null => {
+  const expression = (node.heritageClauses?.flatMap((clause) => [...clause.types]) ?? [])[0]?.expression;
+  return expression && ts.isCallExpression(expression) ? expression : null;
+};
+
+const factoryArrowOf = (call: ts.CallExpression): ts.ArrowFunction | ts.FunctionExpression | null => {
+  const arg = call.arguments.find((argument) => ts.isArrowFunction(argument) || ts.isFunctionExpression(argument));
+  return arg && (ts.isArrowFunction(arg) || ts.isFunctionExpression(arg)) ? arg : null;
+};
+
+export const hasClassMethod = (content: string, className: string, methodName: string) => {
+  const node = findClassDeclaration(sourceFileFor("service.ts", content), className);
+  return Boolean(
+    node?.members.some((member) => ts.isMethodDeclaration(member) && nodeName(member.name) === methodName),
+  );
+};
+
+export const insertClassMethod = (content: string, className: string, methodBlock: string): string | null => {
+  const source = sourceFileFor("service.ts", content);
+  const node = findClassDeclaration(source, className);
+  if (!node) return null;
+  const closeBrace = node.getEnd() - 1;
+  if (content[closeBrace] !== "}") return null;
+  const lead = content.slice(0, closeBrace).endsWith("\n") ? "" : "\n";
+  return spliceText(content, closeBrace, closeBrace, `${lead}${methodBlock}\n`);
+};
+
+export interface FactoryParamPlan {
+  mode: "destructure" | "positional";
+  name: string;
+}
+
+const arrowParamInnerRegion = (
+  content: string,
+  source: ts.SourceFile,
+  arrow: ts.ArrowFunction | ts.FunctionExpression,
+) => {
+  if (arrow.parameters.length > 0) {
+    return {
+      start: arrow.parameters[0].getStart(source),
+      end: arrow.parameters[arrow.parameters.length - 1].getEnd(),
+    };
+  }
+  const open = content.indexOf("(", arrow.getStart(source));
+  if (open < 0) return null;
+  const close = content.indexOf(")", open);
+  if (close < 0) return null;
+  return { start: open + 1, end: close };
+};
+
+const factoryParamEdit = (
+  content: string,
+  source: ts.SourceFile,
+  arrow: ts.ArrowFunction | ts.FunctionExpression,
+  plan: FactoryParamPlan,
+): { start: number; end: number; text: string } | "unchanged" | null => {
+  if (arrow.parameters.length > 1) return null;
+  const region = arrowParamInnerRegion(content, source, arrow);
+  if (!region) return null;
+  if (arrow.parameters.length === 0) {
+    return { ...region, text: plan.mode === "destructure" ? `{ ${plan.name} }` : plan.name };
+  }
+  const param = arrow.parameters[0];
+  if (plan.mode === "positional") return nodeName(param.name) === plan.name ? "unchanged" : null;
+  if (!ts.isObjectBindingPattern(param.name)) return null;
+  const names = param.name.elements.map((element) => (ts.isIdentifier(element.name) ? element.name.text : null));
+  if (names.some((name) => name === null)) return null;
+  if (names.includes(plan.name)) return "unchanged";
+  return {
+    start: param.getStart(source),
+    end: param.getEnd(),
+    text: `{ ${[...(names as string[]), plan.name].join(", ")} }`,
+  };
+};
+
+const factoryObjectOf = (source: ts.SourceFile, className: string) => {
+  const node = findClassDeclaration(source, className);
+  const call = node ? firstHeritageCall(node) : null;
+  const arrow = call ? factoryArrowOf(call) : null;
+  const object = arrow ? firstObjectReturnedByArrow(arrow) : null;
+  return arrow && object ? { arrow, object } : null;
+};
+
+export const hasSignalFactoryEntry = (content: string, className: string, entryName: string) => {
+  const located = factoryObjectOf(sourceFileFor("signal.ts", content), className);
+  return Boolean(located?.object.properties.some((property) => propertyName(property) === entryName));
+};
+
+export const insertSignalFactoryEntry = (
+  content: string,
+  className: string,
+  entryName: string,
+  entryLine: string,
+  param: FactoryParamPlan,
+): string | null => {
+  const source = sourceFileFor("signal.ts", content);
+  const located = factoryObjectOf(source, className);
+  if (!located) return null;
+  const locator = locatedObject(source, located.object);
+  if (locator.fields.some((field) => field.name === entryName)) return content;
+  // Compute the param edit first (its offsets precede the object), but apply it last so the
+  // object splice (at a higher offset) does not invalidate the param region positions.
+  const paramEdit = factoryParamEdit(content, source, located.arrow, param);
+  if (paramEdit === null) return null;
+  const withEntry = insertOrderedFieldLine(content, locator, entryName, entryLine, {
+    fieldIndent: "  ",
+    closingIndent: "",
+  });
+  if (withEntry === content) return null;
+  return paramEdit === "unchanged" ? withEntry : spliceText(withEntry, paramEdit.start, paramEdit.end, paramEdit.text);
+};

package/workflow/types.ts

@@ -47,6 +47,14 @@ export interface AddEnumFieldInput extends PrimitiveTargetInput {
   includeInLight?: boolean | null;
 }
 
+export interface AddMutationInput extends PrimitiveTargetInput {
+  mutation: string | null;
+}
+
+export interface AddSliceInput extends PrimitiveTargetInput {
+  slice: string | null;
+}
+
 export interface WorkflowInputSpec {
   type: WorkflowInputType;
   required?: boolean;
@@ -472,4 +480,6 @@ export interface WorkflowPrimitiveOperations {
   createUi: (input: PrimitiveTargetInput & { surface: UiSurface }) => Promise<PrimitiveWriteReport>;
   addField: (input: AddFieldInput) => Promise<PrimitiveWriteReport>;
   addEnumField: (input: AddEnumFieldInput) => Promise<PrimitiveWriteReport>;
+  addMutation: (input: AddMutationInput) => Promise<PrimitiveWriteReport>;
+  addSlice: (input: AddSliceInput) => Promise<PrimitiveWriteReport>;
 }