@cosmicdrift/kumiko-framework 0.2.2 → 0.3.0

package/src/engine/feature-ast/extractors/round1.ts

@@ -0,0 +1,110 @@
+import type { CallExpression, SourceFile } from "ts-morph";
+import type {
+  OptionalRequiresPattern,
+  ReadsConfigPattern,
+  RequiresPattern,
+  SystemScopePattern,
+  ToggleablePattern,
+} from "../patterns";
+import { sourceLocationFromNode } from "../source-location";
+import {
+  type ExtractOutput,
+  fail,
+  ok,
+  readBooleanProperty,
+  readVarargsOrArrayProp,
+} from "./shared";
+
+export function extractRequires(
+  call: CallExpression,
+  sourceFile: SourceFile,
+): ExtractOutput<RequiresPattern> {
+  const names = readVarargsOrArrayProp(call, "features");
+  if (!names) {
+    return fail(
+      "requires",
+      sourceLocationFromNode(call, sourceFile),
+      "expected positional string literals or { features: string[] }",
+    );
+  }
+  return ok({
+    kind: "requires",
+    source: sourceLocationFromNode(call, sourceFile),
+    featureNames: names,
+  });
+}
+
+export function extractOptionalRequires(
+  call: CallExpression,
+  sourceFile: SourceFile,
+): ExtractOutput<OptionalRequiresPattern> {
+  const names = readVarargsOrArrayProp(call, "features");
+  if (!names) {
+    return fail(
+      "optionalRequires",
+      sourceLocationFromNode(call, sourceFile),
+      "expected positional string literals or { features: string[] }",
+    );
+  }
+  return ok({
+    kind: "optionalRequires",
+    source: sourceLocationFromNode(call, sourceFile),
+    featureNames: names,
+  });
+}
+
+export function extractReadsConfig(
+  call: CallExpression,
+  sourceFile: SourceFile,
+): ExtractOutput<ReadsConfigPattern> {
+  const keys = readVarargsOrArrayProp(call, "keys");
+  if (!keys) {
+    return fail(
+      "readsConfig",
+      sourceLocationFromNode(call, sourceFile),
+      "expected positional string literals or { keys: string[] }",
+    );
+  }
+  return ok({
+    kind: "readsConfig",
+    source: sourceLocationFromNode(call, sourceFile),
+    qualifiedKeys: keys,
+  });
+}
+
+export function extractSystemScope(
+  call: CallExpression,
+  sourceFile: SourceFile,
+): ExtractOutput<SystemScopePattern> {
+  return ok({
+    kind: "systemScope",
+    source: sourceLocationFromNode(call, sourceFile),
+  });
+}
+
+export function extractToggleable(
+  call: CallExpression,
+  sourceFile: SourceFile,
+): ExtractOutput<ToggleablePattern> {
+  const arg = call.getArguments()[0];
+  if (!arg) {
+    return fail(
+      "toggleable",
+      sourceLocationFromNode(call, sourceFile),
+      "expected an object argument with a `default` boolean",
+    );
+  }
+  const defaultValue = readBooleanProperty(arg, "default");
+  if (defaultValue === undefined) {
+    return fail(
+      "toggleable",
+      sourceLocationFromNode(call, sourceFile),
+      "argument must be `{ default: true | false }`",
+    );
+  }
+  return ok({
+    kind: "toggleable",
+    source: sourceLocationFromNode(call, sourceFile),
+    default: defaultValue,
+  });
+}

package/src/engine/feature-ast/extractors/round2.ts

@@ -0,0 +1,253 @@
+import type { CallExpression, SourceFile } from "ts-morph";
+import { SyntaxKind } from "ts-morph";
+import type { EntityDefinition } from "../../types/fields";
+import type { NavDefinition } from "../../types/nav";
+import type { RelationDefinition } from "../../types/relations";
+import type { WorkspaceDefinition } from "../../types/workspace";
+import type { EntityPattern, NavPattern, RelationPattern, WorkspacePattern } from "../patterns";
+import { sourceLocationFromNode } from "../source-location";
+import {
+  type ExtractOutput,
+  fail,
+  isPlainObject,
+  ok,
+  readDataLiteralNode,
+  readNameOrRef,
+} from "./shared";
+
+export function extractEntity(
+  call: CallExpression,
+  sourceFile: SourceFile,
+): ExtractOutput<EntityPattern> {
+  const args = call.getArguments();
+  const first = args[0];
+  if (!first) {
+    return fail(
+      "entity",
+      sourceLocationFromNode(call, sourceFile),
+      "expected at least one argument",
+    );
+  }
+
+  const obj = first.asKind(SyntaxKind.ObjectLiteralExpression);
+  if (obj && args.length === 1) {
+    const nameInit = obj
+      .getProperty("name")
+      ?.asKind(SyntaxKind.PropertyAssignment)
+      ?.getInitializer()
+      ?.asKind(SyntaxKind.StringLiteral);
+    if (!nameInit) {
+      return fail(
+        "entity",
+        sourceLocationFromNode(call, sourceFile),
+        "object form requires a string-literal `name` property",
+      );
+    }
+    const definition = readDataLiteralNode(obj);
+    if (!isPlainObject(definition)) {
+      return fail(
+        "entity",
+        sourceLocationFromNode(call, sourceFile),
+        "definition could not be read as a plain object (contains functions or identifiers)",
+      );
+    }
+    const { name: _name, ...defWithoutName } = definition;
+    return ok({
+      kind: "entity",
+      source: sourceLocationFromNode(call, sourceFile),
+      entityName: nameInit.getLiteralValue(),
+      definition: defWithoutName as EntityDefinition,
+    });
+  }
+
+  const nameArg = first.asKind(SyntaxKind.StringLiteral);
+  if (!nameArg) {
+    return fail(
+      "entity",
+      sourceLocationFromNode(call, sourceFile),
+      "first argument must be a string literal name (or use the object form)",
+    );
+  }
+  const defArg = args[1];
+  if (!defArg) {
+    return fail(
+      "entity",
+      sourceLocationFromNode(call, sourceFile),
+      "expected a definition object as second argument",
+    );
+  }
+  const definition = readDataLiteralNode(defArg);
+  if (!isPlainObject(definition)) {
+    return fail(
+      "entity",
+      sourceLocationFromNode(call, sourceFile),
+      "definition could not be read as a plain object (contains functions or identifiers)",
+    );
+  }
+  return ok({
+    kind: "entity",
+    source: sourceLocationFromNode(call, sourceFile),
+    entityName: nameArg.getLiteralValue(),
+    definition: definition as EntityDefinition,
+  });
+}
+
+export function extractRelation(
+  call: CallExpression,
+  sourceFile: SourceFile,
+): ExtractOutput<RelationPattern> {
+  const args = call.getArguments();
+  const first = args[0];
+  if (!first) {
+    return fail(
+      "relation",
+      sourceLocationFromNode(call, sourceFile),
+      "expected at least one argument",
+    );
+  }
+
+  const obj = first.asKind(SyntaxKind.ObjectLiteralExpression);
+  if (obj && args.length === 1) {
+    const entityInit = obj
+      .getProperty("entity")
+      ?.asKind(SyntaxKind.PropertyAssignment)
+      ?.getInitializer();
+    if (!entityInit) {
+      return fail(
+        "relation",
+        sourceLocationFromNode(call, sourceFile),
+        "object form requires an `entity` property",
+      );
+    }
+    const entityName = readNameOrRef(entityInit);
+    if (!entityName) {
+      return fail(
+        "relation",
+        sourceLocationFromNode(call, sourceFile),
+        '`entity` must be a string literal or `{ name: "..." }` ref',
+      );
+    }
+    const nameInit = obj
+      .getProperty("name")
+      ?.asKind(SyntaxKind.PropertyAssignment)
+      ?.getInitializer()
+      ?.asKind(SyntaxKind.StringLiteral);
+    if (!nameInit) {
+      return fail(
+        "relation",
+        sourceLocationFromNode(call, sourceFile),
+        "object form requires a string-literal `name` property",
+      );
+    }
+    const definition = readDataLiteralNode(obj);
+    if (!isPlainObject(definition)) {
+      return fail(
+        "relation",
+        sourceLocationFromNode(call, sourceFile),
+        "definition could not be read as a plain object",
+      );
+    }
+    const { entity: _e, name: _n, ...defWithoutCarriers } = definition;
+    return ok({
+      kind: "relation",
+      source: sourceLocationFromNode(call, sourceFile),
+      entityName,
+      relationName: nameInit.getLiteralValue(),
+      definition: defWithoutCarriers as RelationDefinition,
+    });
+  }
+
+  const entityName = readNameOrRef(first);
+  if (!entityName) {
+    return fail(
+      "relation",
+      sourceLocationFromNode(call, sourceFile),
+      'first argument must be a string literal or an inline { name: "..." } object (or use the object form)',
+    );
+  }
+  const nameArg = args[1]?.asKind(SyntaxKind.StringLiteral);
+  if (!nameArg) {
+    return fail(
+      "relation",
+      sourceLocationFromNode(call, sourceFile),
+      "second argument must be a string literal relation name",
+    );
+  }
+  const defArg = args[2];
+  if (!defArg) {
+    return fail(
+      "relation",
+      sourceLocationFromNode(call, sourceFile),
+      "expected a definition object as third argument",
+    );
+  }
+  const definition = readDataLiteralNode(defArg);
+  if (!isPlainObject(definition)) {
+    return fail(
+      "relation",
+      sourceLocationFromNode(call, sourceFile),
+      "definition could not be read as a plain object",
+    );
+  }
+  return ok({
+    kind: "relation",
+    source: sourceLocationFromNode(call, sourceFile),
+    entityName,
+    relationName: nameArg.getLiteralValue(),
+    definition: definition as RelationDefinition,
+  });
+}
+
+export function extractNav(
+  call: CallExpression,
+  sourceFile: SourceFile,
+): ExtractOutput<NavPattern> {
+  const arg = call.getArguments()[0];
+  if (!arg) {
+    return fail(
+      "nav",
+      sourceLocationFromNode(call, sourceFile),
+      "expected a NavDefinition object as first argument",
+    );
+  }
+  const definition = readDataLiteralNode(arg);
+  if (!isPlainObject(definition)) {
+    return fail(
+      "nav",
+      sourceLocationFromNode(call, sourceFile),
+      "definition could not be read as a plain object",
+    );
+  }
+  return ok({
+    kind: "nav",
+    source: sourceLocationFromNode(call, sourceFile),
+    definition: definition as NavDefinition,
+  });
+}
+
+export function extractWorkspace(
+  call: CallExpression,
+  sourceFile: SourceFile,
+): ExtractOutput<WorkspacePattern> {
+  const arg = call.getArguments()[0];
+  if (!arg) {
+    return fail(
+      "workspace",
+      sourceLocationFromNode(call, sourceFile),
+      "expected a WorkspaceDefinition object as first argument",
+    );
+  }
+  const definition = readDataLiteralNode(arg);
+  if (!isPlainObject(definition)) {
+    return fail(
+      "workspace",
+      sourceLocationFromNode(call, sourceFile),
+      "definition could not be read as a plain object",
+    );
+  }
+  return ok({
+    kind: "workspace",
+    source: sourceLocationFromNode(call, sourceFile),
+    definition: definition as WorkspaceDefinition,
+  });
+}