swallowkit 1.0.0-beta.19 → 1.0.0-beta.20

package/src/core/operations/create-model.ts

@@ -0,0 +1,174 @@
+import * as fs from "fs";
+import * as path from "path";
+import { ensureSwallowKitProject, loadConfig } from "../config";
+import { toPascalCase } from "../scaffold/model-parser";
+import { syncProjectManifest } from "../project/manifest";
+
+export interface CreateModelOperationOptions {
+  names: string[];
+  modelsDir?: string;
+  connector?: string;
+  overwriteMode?: "prompt" | "always" | "never";
+  confirmOverwrite?: (filePath: string) => Promise<boolean>;
+}
+
+export interface CreateModelOperationResult {
+  createdFiles: string[];
+  skippedFiles: string[];
+  updatedIndex: boolean;
+  connectorType?: "rdb" | "api";
+}
+
+function generateModelTemplate(modelName: string): string {
+  const pascalName = toPascalCase(modelName);
+
+  return `import { z } from 'zod/v4';
+
+// ${pascalName} model (Zod official pattern: same name for value and type)
+export const ${pascalName} = z.object({
+  id: z.string(),
+  name: z.string().min(1),
+  createdAt: z.string().optional(),
+  updatedAt: z.string().optional(),
+});
+
+export type ${pascalName} = z.infer<typeof ${pascalName}>;
+
+// Display name for UI
+export const displayName = '${pascalName}';
+`;
+}
+
+function generateConnectorModelTemplate(modelName: string, connectorName: string, connectorType: "rdb" | "api"): string {
+  const pascalName = toPascalCase(modelName);
+  const kebabName = modelName.toLowerCase().replace(/[^a-z0-9]+/g, "-");
+  const pluralName = kebabName.endsWith("s") ? kebabName : `${kebabName}s`;
+
+  const schema = `import { z } from 'zod/v4';
+
+// ${pascalName} model (Zod official pattern: same name for value and type)
+export const ${pascalName} = z.object({
+  id: z.string(),
+  name: z.string().min(1),
+  createdAt: z.string().optional(),
+  updatedAt: z.string().optional(),
+});
+
+export type ${pascalName} = z.infer<typeof ${pascalName}>;
+
+// Display name for UI
+export const displayName = '${pascalName}';
+`;
+
+  if (connectorType === "rdb") {
+    return `${schema}
+// SwallowKit Connector Metadata
+export const connectorConfig = {
+  connector: '${connectorName}',
+  operations: ['getAll', 'getById'] as const,
+  table: '${pluralName}',
+  idColumn: 'id',
+};
+`;
+  }
+
+  return `${schema}
+// SwallowKit Connector Metadata
+export const connectorConfig = {
+  connector: '${connectorName}',
+  operations: ['getAll', 'getById', 'create', 'update'] as const,
+  endpoints: {
+    getAll: 'GET /${pluralName}',
+    getById: 'GET /${pluralName}/{id}',
+    create: 'POST /${pluralName}',
+    update: 'PATCH /${pluralName}/{id}',
+  },
+};
+`;
+}
+
+function updateSharedIndex(kebabName: string, pascalName: string): boolean {
+  const indexPath = path.join("shared", "index.ts");
+
+  if (!fs.existsSync(indexPath)) {
+    return false;
+  }
+
+  const content = fs.readFileSync(indexPath, "utf-8");
+  const exportLine = `export { ${pascalName} } from './models/${kebabName}';`;
+
+  if (content.includes(exportLine)) {
+    return false;
+  }
+
+  fs.appendFileSync(indexPath, `${exportLine}\n`);
+  return true;
+}
+
+export async function createModelOperation(options: CreateModelOperationOptions): Promise<CreateModelOperationResult> {
+  ensureSwallowKitProject("create-model");
+
+  let connectorType: "rdb" | "api" | undefined;
+  if (options.connector) {
+    const config = loadConfig();
+    const connectorDefinition = config.connectors?.[options.connector];
+    if (!connectorDefinition) {
+      throw new Error(
+        `Connector '${options.connector}' not found in swallowkit.config.js. ` +
+          `Run 'swallowkit add-connector ${options.connector} --type=<rdb|api>' first.`
+      );
+    }
+
+    connectorType = connectorDefinition.type;
+  }
+
+  const modelsDir = options.modelsDir || "shared/models";
+  if (!fs.existsSync(modelsDir)) {
+    fs.mkdirSync(modelsDir, { recursive: true });
+  }
+
+  const createdFiles: string[] = [];
+  const skippedFiles: string[] = [];
+  let updatedIndex = false;
+
+  for (const name of options.names) {
+    const kebabName = name.toLowerCase().replace(/[^a-z0-9]+/g, "-");
+    const filePath = path.join(modelsDir, `${kebabName}.ts`);
+    const pascalName = toPascalCase(name);
+
+    if (fs.existsSync(filePath)) {
+      const overwriteMode = options.overwriteMode || "prompt";
+      const shouldOverwrite = overwriteMode === "always"
+        ? true
+        : overwriteMode === "never"
+          ? false
+          : options.confirmOverwrite
+            ? await options.confirmOverwrite(filePath)
+            : false;
+
+      if (!shouldOverwrite) {
+        skippedFiles.push(filePath.replace(/\\/g, "/"));
+        continue;
+      }
+    }
+
+    const content = options.connector && connectorType
+      ? generateConnectorModelTemplate(name, options.connector, connectorType)
+      : generateModelTemplate(name);
+    fs.writeFileSync(filePath, content, "utf-8");
+    createdFiles.push(filePath.replace(/\\/g, "/"));
+
+    if (updateSharedIndex(kebabName, pascalName)) {
+      updatedIndex = true;
+    }
+  }
+
+  await syncProjectManifest();
+
+  return {
+    createdFiles,
+    skippedFiles,
+    updatedIndex,
+    ...(connectorType ? { connectorType } : {}),
+  };
+}

package/src/core/operations/runtime.ts

@@ -0,0 +1,235 @@
+import * as fs from "fs";
+import * as path from "path";
+
+export interface CapturedConsoleMessages {
+  logs: string[];
+  warnings: string[];
+  errors: string[];
+}
+
+export interface FileMutationSummary {
+  createdFiles: string[];
+  updatedFiles: string[];
+  appendedFiles: string[];
+  deletedFiles: string[];
+  createdDirectories: string[];
+}
+
+export class ProcessExitInterceptError extends Error {
+  readonly exitCode: number;
+
+  constructor(exitCode: number) {
+    super(`Process exited with code ${exitCode}`);
+    this.name = "ProcessExitInterceptError";
+    this.exitCode = exitCode;
+  }
+}
+
+function formatConsoleArgs(args: unknown[]): string {
+  return args
+    .map((arg) => {
+      if (typeof arg === "string") {
+        return arg;
+      }
+
+      if (arg instanceof Error) {
+        return arg.stack || arg.message;
+      }
+
+      try {
+        return JSON.stringify(arg);
+      } catch {
+        return String(arg);
+      }
+    })
+    .join(" ");
+}
+
+function normalizePathForSummary(targetPath: string): string {
+  const relative = path.relative(process.cwd(), targetPath);
+  return relative && !relative.startsWith("..") ? relative.replace(/\\/g, "/") : targetPath.replace(/\\/g, "/");
+}
+
+interface FileSystemEntrySnapshot {
+  type: "file" | "directory";
+  mtimeMs: number;
+  size: number;
+}
+
+function snapshotFileSystem(rootDirectory: string): Map<string, FileSystemEntrySnapshot> {
+  const snapshot = new Map<string, FileSystemEntrySnapshot>();
+  const excludedDirectoryNames = new Set([".git", "node_modules"]);
+
+  function walk(currentDirectory: string): void {
+    for (const entry of fs.readdirSync(currentDirectory, { withFileTypes: true })) {
+      if (entry.isDirectory() && excludedDirectoryNames.has(entry.name)) {
+        continue;
+      }
+
+      const entryPath = path.join(currentDirectory, entry.name);
+      const stats = fs.statSync(entryPath);
+      snapshot.set(entryPath, {
+        type: entry.isDirectory() ? "directory" : "file",
+        mtimeMs: stats.mtimeMs,
+        size: stats.size,
+      });
+
+      if (entry.isDirectory()) {
+        walk(entryPath);
+      }
+    }
+  }
+
+  if (fs.existsSync(rootDirectory)) {
+    walk(rootDirectory);
+  }
+
+  return snapshot;
+}
+
+export async function withWorkingDirectory<T>(directory: string, action: () => Promise<T>): Promise<T> {
+  const originalDirectory = process.cwd();
+  process.chdir(directory);
+
+  try {
+    return await action();
+  } finally {
+    process.chdir(originalDirectory);
+  }
+}
+
+export async function captureConsoleMessages<T>(
+  action: () => Promise<T>
+): Promise<{ result: T; messages: CapturedConsoleMessages }> {
+  const messages: CapturedConsoleMessages = {
+    logs: [],
+    warnings: [],
+    errors: [],
+  };
+
+  const originalLog = console.log;
+  const originalWarn = console.warn;
+  const originalError = console.error;
+
+  console.log = (...args: unknown[]) => {
+    messages.logs.push(formatConsoleArgs(args));
+  };
+  console.warn = (...args: unknown[]) => {
+    messages.warnings.push(formatConsoleArgs(args));
+  };
+  console.error = (...args: unknown[]) => {
+    messages.errors.push(formatConsoleArgs(args));
+  };
+
+  try {
+    const result = await action();
+    return { result, messages };
+  } finally {
+    console.log = originalLog;
+    console.warn = originalWarn;
+    console.error = originalError;
+  }
+}
+
+export async function captureConsoleMessagesWithError<T>(
+  action: () => Promise<T>
+): Promise<{ result?: T; messages: CapturedConsoleMessages; error?: unknown }> {
+  const messages: CapturedConsoleMessages = {
+    logs: [],
+    warnings: [],
+    errors: [],
+  };
+
+  const originalLog = console.log;
+  const originalWarn = console.warn;
+  const originalError = console.error;
+
+  console.log = (...args: unknown[]) => {
+    messages.logs.push(formatConsoleArgs(args));
+  };
+  console.warn = (...args: unknown[]) => {
+    messages.warnings.push(formatConsoleArgs(args));
+  };
+  console.error = (...args: unknown[]) => {
+    messages.errors.push(formatConsoleArgs(args));
+  };
+
+  try {
+    return { result: await action(), messages };
+  } catch (error) {
+    return { messages, error };
+  } finally {
+    console.log = originalLog;
+    console.warn = originalWarn;
+    console.error = originalError;
+  }
+}
+
+export async function interceptProcessExit<T>(action: () => Promise<T>): Promise<T> {
+  const originalExit = process.exit;
+
+  process.exit = ((code?: number | string | null) => {
+    const normalizedCode = typeof code === "number"
+      ? code
+      : typeof process.exitCode === "number"
+        ? process.exitCode
+        : 1;
+    throw new ProcessExitInterceptError(normalizedCode);
+  }) as typeof process.exit;
+
+  try {
+    return await action();
+  } finally {
+    process.exit = originalExit;
+  }
+}
+
+export async function trackFileMutations<T>(
+  action: () => Promise<T>
+): Promise<{ result: T; mutations: FileMutationSummary }> {
+  const rootDirectory = process.cwd();
+  const before = snapshotFileSystem(rootDirectory);
+  const result = await action();
+  const after = snapshotFileSystem(rootDirectory);
+
+  const createdFiles = new Set<string>();
+  const updatedFiles = new Set<string>();
+  const deletedFiles = new Set<string>();
+  const createdDirectories = new Set<string>();
+
+  for (const [entryPath, afterEntry] of after.entries()) {
+    const beforeEntry = before.get(entryPath);
+    if (!beforeEntry) {
+      if (afterEntry.type === "directory") {
+        createdDirectories.add(normalizePathForSummary(entryPath));
+      } else {
+        createdFiles.add(normalizePathForSummary(entryPath));
+      }
+      continue;
+    }
+
+    if (
+      afterEntry.type === "file" &&
+      (beforeEntry.mtimeMs !== afterEntry.mtimeMs || beforeEntry.size !== afterEntry.size)
+    ) {
+      updatedFiles.add(normalizePathForSummary(entryPath));
+    }
+  }
+
+  for (const [entryPath, beforeEntry] of before.entries()) {
+    if (!after.has(entryPath) && beforeEntry.type === "file") {
+      deletedFiles.add(normalizePathForSummary(entryPath));
+    }
+  }
+
+  return {
+    result,
+    mutations: {
+      createdFiles: Array.from(createdFiles).sort(),
+      updatedFiles: Array.from(updatedFiles).sort(),
+      appendedFiles: [],
+      deletedFiles: Array.from(deletedFiles).sort(),
+      createdDirectories: Array.from(createdDirectories).sort(),
+    },
+  };
+}

package/src/core/operations/scaffold-machine.ts

@@ -0,0 +1,91 @@
+import { scaffoldCommand } from "../../cli/commands/scaffold";
+import {
+  captureConsoleMessagesWithError,
+  interceptProcessExit,
+  ProcessExitInterceptError,
+  trackFileMutations,
+} from "./runtime";
+
+export interface MachineScaffoldOperationOptions {
+  model: string;
+  functionsDir?: string;
+  apiDir?: string;
+  apiOnly?: boolean;
+}
+
+export interface MachineScaffoldOperationResult {
+  createdFiles: string[];
+  updatedFiles: string[];
+  appendedFiles: string[];
+  deletedFiles: string[];
+  createdDirectories: string[];
+  diagnostics: string[];
+}
+
+function deriveErrorMessage(messages: { errors: string[]; warnings: string[]; logs: string[] }): string {
+  const errorText = messages.errors[messages.errors.length - 1];
+  if (errorText) {
+    return errorText.replace(/^\s*❌\s*/, "").trim();
+  }
+
+  const warningText = messages.warnings[messages.warnings.length - 1];
+  if (warningText) {
+    return warningText.trim();
+  }
+
+  const logText = messages.logs[messages.logs.length - 1];
+  if (logText) {
+    return logText.trim();
+  }
+
+  return "Scaffold failed.";
+}
+
+export async function runMachineScaffoldOperation(
+  options: MachineScaffoldOperationOptions
+): Promise<MachineScaffoldOperationResult> {
+  const originalMachineOutput = process.env.SWALLOWKIT_MACHINE_OUTPUT;
+  process.env.SWALLOWKIT_MACHINE_OUTPUT = "1";
+
+  try {
+    const tracked = await trackFileMutations(async () => {
+      const captured = await captureConsoleMessagesWithError(async () => {
+        await interceptProcessExit(async () => {
+          await scaffoldCommand(options);
+        });
+      });
+
+      if (captured.error) {
+        if (captured.error instanceof ProcessExitInterceptError) {
+          throw new Error(deriveErrorMessage(captured.messages));
+        }
+
+        if (captured.error instanceof Error) {
+          throw captured.error;
+        }
+
+        throw new Error(deriveErrorMessage(captured.messages));
+      }
+
+      return captured.messages;
+    });
+
+    return {
+      createdFiles: tracked.mutations.createdFiles,
+      updatedFiles: tracked.mutations.updatedFiles,
+      appendedFiles: tracked.mutations.appendedFiles,
+      deletedFiles: tracked.mutations.deletedFiles,
+      createdDirectories: tracked.mutations.createdDirectories,
+      diagnostics: [
+        ...tracked.result.warnings.map((warning) => `warning:${warning}`),
+        ...tracked.result.errors.map((error) => `error:${error}`),
+      ],
+    };
+  } finally {
+    if (originalMachineOutput === undefined) {
+      delete process.env.SWALLOWKIT_MACHINE_OUTPUT;
+    } else {
+      process.env.SWALLOWKIT_MACHINE_OUTPUT = originalMachineOutput;
+    }
+  }
+}