@akanjs/devkit 3.1.1 → 3.1.2-rc.1

package/workflow/mutationScaffold.ts

@@ -1,4 +1,4 @@
-import { lowerlize } from "akanjs/common";
+import { lowerlize, modelNames } from "akanjs/common";
 import type { Sys } from "../commandDecorators";
 import { GuardCatalog } from "./guardCatalog";
 import { type MutationActingUser, type MutationCall, MutationSource } from "./mutationSource";
@@ -53,20 +53,34 @@ export class MutationScaffold {
   }
 
   static reservedNamesOf(modelClassName: string) {
-    const model = lowerlize(modelClassName);
-    const prefixed = ["light", "create", "update", "remove", "view", "edit", "merge", "get", "load", "set", "reset"];
+    const names = modelNames(lowerlize(modelClassName));
     return new Set([
-      model,
-      ...[...prefixed, "new", "submit", "invalidate"].map((prefix) => `${prefix}${modelClassName}`),
-      `create${modelClassName}InForm`,
-      `update${modelClassName}InForm`,
-      `load${modelClassName}Many`,
-      `get${modelClassName}View`,
-      `get${modelClassName}Edit`,
-      `add${modelClassName}Files`,
-      `check${modelClassName}Submitable`,
-      `writeOn${modelClassName}`,
-      ...["load", "restore", "discard"].map((prefix) => `${prefix}${modelClassName}FormDraft`),
+      names.model,
+      names.lightModel,
+      names.createModel,
+      names.updateModel,
+      names.removeModel,
+      names.viewModel,
+      names.editModel,
+      names.mergeModel,
+      names.getModel,
+      names.loadModel,
+      names.setModel,
+      names.resetModel,
+      names.newModel,
+      names.submitModel,
+      names.invalidateModel,
+      names.createModelInForm,
+      names.updateModelInForm,
+      names.loadModelMany,
+      names.getModelView,
+      names.getModelEdit,
+      names.addModelFiles,
+      names.checkModelSubmitable,
+      names.writeOnModel,
+      names.loadModelFormDraft,
+      names.restoreModelFormDraft,
+      names.discardModelFormDraft,
     ]);
   }
 
@@ -415,17 +429,17 @@ export class MutationScaffold {
   #parametersOf(service: ServiceSource, ref: string, method: string) {
     const declared = classMethodParameters(service.content, service.className, method);
     if (declared) return declared;
-    const modelClassName = moduleComponentName(ref);
+    const names = modelNames(lowerlize(moduleComponentName(ref)));
     const generated: Record<string, { name: string; optional: boolean }[]> = {
-      [`get${modelClassName}`]: [{ name: "id", optional: false }],
-      [`load${modelClassName}`]: [{ name: "id", optional: true }],
-      [`load${modelClassName}Many`]: [{ name: "ids", optional: false }],
-      [`create${modelClassName}`]: [{ name: "data", optional: false }],
-      [`update${modelClassName}`]: [
+      [names.getModel]: [{ name: "id", optional: false }],
+      [names.loadModel]: [{ name: "id", optional: true }],
+      [names.loadModelMany]: [{ name: "ids", optional: false }],
+      [names.createModel]: [{ name: "data", optional: false }],
+      [names.updateModel]: [
         { name: "id", optional: false },
         { name: "data", optional: false },
       ],
-      [`remove${modelClassName}`]: [{ name: "id", optional: false }],
+      [names.removeModel]: [{ name: "id", optional: false }],
     };
     return generated[method] ?? null;
   }

package/workflow/plan.ts

@@ -19,6 +19,24 @@ import { addFieldUiPolicyForType } from "./uiPolicy";
 
 const surfaceModes = new Set<WorkflowSurfaceMode>(["infer", "include", "skip"]);
 
+const sysNamePattern = /^[a-z0-9][a-zA-Z0-9_-]*$/;
+const identifierPattern = /^_{0,2}[a-zA-Z][a-zA-Z0-9_-]*$/;
+//? These inputs become path segments, identifiers and command arguments, so none may carry a separator or a dot.
+const nameInputPatterns: Record<string, RegExp> = {
+  app: sysNamePattern,
+  module: identifierPattern,
+  scalar: identifierPattern,
+  field: identifierPattern,
+  slice: identifierPattern,
+  mutation: identifierPattern,
+  interaction: identifierPattern,
+};
+
+export const isWorkflowSysName = (value: unknown): value is string =>
+  typeof value === "string" && sysNamePattern.test(value);
+export const isWorkflowModuleName = (value: unknown): value is string =>
+  typeof value === "string" && identifierPattern.test(value);
+
 const parseStringList = (value: unknown) => {
   if (Array.isArray(value)) {
     const values = value.filter((item): item is string => typeof item === "string" && item.trim().length > 0);
@@ -365,6 +383,16 @@ export const createWorkflowPlan = (spec: WorkflowSpec, rawInputs: Record<string,
       });
       continue;
     }
+    const namePattern = nameInputPatterns[name];
+    if (namePattern && typeof value === "string" && !namePattern.test(value)) {
+      diagnostics.push({
+        severity: "error",
+        code: "workflow-input-invalid",
+        input: name,
+        message: `Workflow ${spec.name} input "${name}" must be a plain name without dots, slashes or spaces, not ${JSON.stringify(value)}.`,
+      });
+      continue;
+    }
     if (inputSpec.allowedValues && typeof value === "string" && !inputSpec.allowedValues.includes(value)) {
       diagnostics.push({
         severity: "error",

package/workflow/sourceAst.ts

@@ -1,50 +1,12 @@
+import { createAst } from "@akanjs/language";
 import ts from "typescript";
 
-export const sourceFileFor = (fileName: string, content: string) =>
-  ts.createSourceFile(fileName, content, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
-
-export const nodeName = (node: ts.PropertyName | ts.BindingName | undefined) => {
-  if (!node) return null;
-  if (ts.isIdentifier(node) || ts.isStringLiteral(node) || ts.isNumericLiteral(node)) return node.text;
-  return null;
-};
-
-export const propertyName = (node: ts.ObjectLiteralElementLike) =>
-  ts.isPropertyAssignment(node) || ts.isShorthandPropertyAssignment(node) || ts.isMethodDeclaration(node)
-    ? nodeName(node.name)
-    : null;
-
-export const expressionName = (expression: ts.Expression): string | null => {
-  if (ts.isIdentifier(expression)) return expression.text;
-  if (ts.isPropertyAccessExpression(expression)) return expression.name.text;
-  if (ts.isCallExpression(expression)) return expressionName(expression.expression);
-  if (ts.isAsExpression(expression)) return expressionName(expression.expression);
-  return null;
-};
-
-export const callExpressionName = (node: ts.CallExpression) =>
-  ts.isPropertyAccessExpression(node.expression) ? node.expression.name.text : expressionName(node.expression);
-
-export const firstObjectReturnedByArrow = (node: ts.Node): ts.ObjectLiteralExpression | null => {
-  if (!ts.isArrowFunction(node) && !ts.isFunctionExpression(node)) return null;
-  if (ts.isObjectLiteralExpression(node.body)) return node.body;
-  if (ts.isParenthesizedExpression(node.body) && ts.isObjectLiteralExpression(node.body.expression)) {
-    return node.body.expression;
-  }
-  if (!ts.isBlock(node.body)) return null;
-  for (const statement of node.body.statements) {
-    if (ts.isReturnStatement(statement) && statement.expression && ts.isObjectLiteralExpression(statement.expression)) {
-      return statement.expression;
-    }
-  }
-  return null;
-};
-
-const isViaCall = (expression: ts.Expression) =>
-  ts.isCallExpression(expression) && expressionName(expression.expression) === "via";
-
-export const heritageCall = (node: ts.ClassDeclaration) => {
-  const heritage = node.heritageClauses?.flatMap((clause) => [...clause.types]) ?? [];
-  const expression = heritage.find((clause) => isViaCall(clause.expression))?.expression;
-  return expression && ts.isCallExpression(expression) ? expression : null;
-};
+export const {
+  sourceFileFor,
+  nodeName,
+  propertyName,
+  expressionName,
+  callExpressionName,
+  firstObjectReturnedByArrow,
+  heritageCall,
+} = createAst(ts);