@nakedev/go-scaffold 0.1.2 → 0.1.4

package/tests/integration/legacy-method-compat.test.mjs

@@ -0,0 +1,222 @@
+import assert from "node:assert/strict";
+import { execFileSync } from "node:child_process";
+import {
+  existsSync,
+  mkdirSync,
+  mkdtempSync,
+  readFileSync,
+  readdirSync,
+  renameSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import test from "node:test";
+import { fileURLToPath } from "node:url";
+
+const ROOT = path.dirname(path.dirname(path.dirname(fileURLToPath(import.meta.url))));
+const CLI = path.join(ROOT, "bin", "go-scaffold.js");
+
+function run(command, args, cwd) {
+  return execFileSync(command, args, {
+    cwd,
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"],
+  });
+}
+
+function rewriteGoTree(dir, rewrite) {
+  for (const entry of readdirSync(dir, { withFileTypes: true })) {
+    const target = path.join(dir, entry.name);
+    if (entry.isDirectory()) rewriteGoTree(target, rewrite);
+    else if (entry.name.endsWith(".go")) {
+      writeFileSync(target, rewrite(readFileSync(target, "utf8")));
+    }
+  }
+}
+
+function convertToLegacyPluralModule(project) {
+  const canonicalDir = path.join(project, "internal", "app", "order");
+  const legacyDir = path.join(project, "internal", "app", "orders");
+  renameSync(canonicalDir, legacyDir);
+  rewriteGoTree(legacyDir, (source) =>
+    source
+      .replace(/^package order$/m, "package orders")
+      .replaceAll("sample/internal/app/order/model", "sample/internal/app/orders/model")
+      .replaceAll("model.Order", "model.Orders")
+      .replaceAll("ErrOrder", "ErrOrders")
+      .replace("type Order struct", "type Orders struct")
+      .replaceAll("func (Order)", "func (Orders)")
+      .replace('return "orders"', 'return "orderses"')
+      .replace('Group("/orders"', 'Group("/orderses"')
+  );
+
+  const mainPath = path.join(project, "cmd", "api", "main.go");
+  const legacyMain = readFileSync(mainPath, "utf8")
+    .replaceAll("sample/internal/app/order", "sample/internal/app/orders")
+    .replaceAll("ordermodel.Order", "ordersmodel.Orders")
+    .replaceAll("ordermodel", "ordersmodel")
+    .replaceAll("order.New", "orders.New")
+    .replaceAll("orderRepo", "ordersRepo")
+    .replaceAll("orderService", "ordersService")
+    .replaceAll("orderHandler", "ordersHandler");
+  writeFileSync(mainPath, legacyMain);
+
+  const docsDir = path.join(project, "docs");
+  const canonicalDocs = path.join(docsDir, "orders");
+  const legacyDocs = path.join(docsDir, "orderses");
+  if (existsSync(canonicalDocs)) {
+    renameSync(canonicalDocs, legacyDocs);
+    for (const name of readdirSync(legacyDocs)) {
+      const target = path.join(legacyDocs, name);
+      if (!name.endsWith(".yaml")) continue;
+      writeFileSync(target, readFileSync(target, "utf8").replaceAll("Order", "Orders"));
+    }
+  }
+  const openapiPath = path.join(docsDir, "openapi.yaml");
+  if (existsSync(openapiPath)) {
+    writeFileSync(
+      openapiPath,
+      readFileSync(openapiPath, "utf8")
+        .replaceAll("/v1/orders", "/v1/orderses")
+        .replaceAll("./orders/", "./orderses/")
+        .replaceAll("OrderCreate", "OrdersCreate")
+        .replaceAll("OrderUpdate", "OrdersUpdate")
+        .replaceAll("OrderResponse", "OrdersResponse")
+    );
+  }
+
+  const migrationsDir = path.join(project, "migrations");
+  for (const name of readdirSync(migrationsDir)) {
+    if (!name.includes("_create_orders.")) continue;
+    const source = path.join(migrationsDir, name);
+    const target = path.join(migrationsDir, name.replace("_create_orders.", "_create_orderses."));
+    writeFileSync(target, readFileSync(source, "utf8").replaceAll("orders", "orderses"));
+    rmSync(source);
+  }
+  return legacyDir;
+}
+
+test("generate module refuses to duplicate a legacy plural package", () => {
+  const scratch = mkdtempSync(path.join(tmpdir(), "go-scaffold-legacy-duplicate-"));
+  try {
+    run("node", [CLI, "create", "sample", "--defaults", "--no-docker"], scratch);
+    const project = path.join(scratch, "sample");
+    mkdirSync(path.join(project, "internal", "app", "orders"), { recursive: true });
+    writeFileSync(path.join(project, "internal", "app", "orders", "legacy.go"), "package orders\n");
+
+    assert.throws(
+      () => run("node", [CLI, "generate", "module", "orders", "--full"], project),
+      /internal\/app\/orders.*already exists/
+    );
+    assert.equal(existsSync(path.join(project, "internal", "app", "order")), false);
+  } finally {
+    rmSync(scratch, { recursive: true, force: true });
+  }
+});
+
+test("remove module locates legacy plural packages and preserves their migrations", () => {
+  const scratch = mkdtempSync(path.join(tmpdir(), "go-scaffold-legacy-remove-"));
+  try {
+    run("node", [CLI, "create", "sample", "--defaults", "--no-docker"], scratch);
+    const project = path.join(scratch, "sample");
+    run("node", [CLI, "generate", "module", "orders", "--full"], project);
+    const legacyDir = convertToLegacyPluralModule(project);
+    const migrationsDir = path.join(project, "migrations");
+    const migrationsBefore = readdirSync(migrationsDir).filter((name) => name.includes("_create_orderses."));
+
+    const output = run("node", [CLI, "remove", "module", "orders", "--yes"], project);
+
+    assert.equal(existsSync(legacyDir), false);
+    for (const name of migrationsBefore) assert.equal(existsSync(path.join(migrationsDir, name)), true);
+    assert.doesNotMatch(readFileSync(path.join(project, "cmd", "api", "main.go"), "utf8"), /internal\/app\/orders/);
+    assert.doesNotMatch(readFileSync(path.join(project, "docs", "openapi.yaml"), "utf8"), /orderses/);
+    assert.match(output, /preserved migration history/);
+  } finally {
+    rmSync(scratch, { recursive: true, force: true });
+  }
+});
+
+test("generate method locates legacy plural packages and concrete handlers", () => {
+  const scratch = mkdtempSync(path.join(tmpdir(), "go-scaffold-legacy-method-"));
+  try {
+    run("node", [CLI, "create", "sample", "--defaults", "--no-docker"], scratch);
+    const project = path.join(scratch, "sample");
+    run("node", [CLI, "generate", "module", "orders", "--full"], project);
+
+    const legacyDir = convertToLegacyPluralModule(project);
+
+    const handlerPath = path.join(legacyDir, "handler.go");
+    const modernHandler = readFileSync(handlerPath, "utf8");
+    const legacyHandler = modernHandler
+      .replace(/type service interface \{[\s\S]*?\/\/ go-scaffold:service-interface\n\}\n\n/, "")
+      .replace('\t"context"\n', "")
+      .replace('\t"sample/internal/app/orders/model"\n', "")
+      .replace('\t"github.com/google/uuid"\n', "")
+      .replace("svc service", "svc *Service")
+      .replace("func NewHandler(svc service", "func NewHandler(svc *Service");
+    writeFileSync(handlerPath, legacyHandler);
+    writeFileSync(path.join(legacyDir, "handler_test.go"), "package orders\n");
+
+    const serviceTestPath = path.join(legacyDir, "service_test.go");
+    writeFileSync(
+      serviceTestPath,
+      `package orders
+
+import (
+	"context"
+	"testing"
+
+	"sample/internal/app/orders/model"
+
+	"github.com/google/uuid"
+)
+
+type fakeRepo struct {
+	err error
+	m   *model.Orders
+}
+
+func (f *fakeRepo) Create(context.Context, *model.Orders) error { return f.err }
+func (f *fakeRepo) FindAll(context.Context, int, int) ([]model.Orders, error) { return nil, f.err }
+func (f *fakeRepo) FindByID(context.Context, uuid.UUID) (*model.Orders, error) {
+	if f.err != nil {
+		return nil, f.err
+	}
+	return f.m, nil
+}
+func (f *fakeRepo) Update(context.Context, *model.Orders) error { return f.err }
+func (f *fakeRepo) Delete(context.Context, uuid.UUID) error { return f.err }
+
+// go-scaffold:fake-repo-methods
+
+func TestGeneratedLegacyFindByStatusReturnsFixture(t *testing.T) {
+	want := &model.Orders{ID: uuid.New()}
+	svc := NewService(&fakeRepo{m: want})
+	got, err := svc.FindByStatus(context.Background(), "active")
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if got != want {
+		t.Fatalf("expected legacy fake fixture %p, got %p", want, got)
+	}
+}
+`
+    );
+
+    run(
+      "node",
+      [CLI, "generate", "method", "order", "findByStatus", "--type", "get", "--get-mode", "one", "--field", "status"],
+      project
+    );
+    assert.match(
+      readFileSync(serviceTestPath, "utf8"),
+      /\/\/nolint:unused\nfunc \(f \*fakeRepo\) FindByStatus/
+    );
+    run("go", ["mod", "tidy"], project);
+    run("go", ["test", "./..."], project);
+  } finally {
+    rmSync(scratch, { recursive: true, force: true });
+  }
+});

package/tests/integration/remove-module.test.mjs

@@ -0,0 +1,58 @@
+import assert from "node:assert/strict";
+import { execFileSync } from "node:child_process";
+import {
+  existsSync,
+  mkdtempSync,
+  readFileSync,
+  readdirSync,
+  rmSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import test from "node:test";
+import { fileURLToPath } from "node:url";
+
+const ROOT = path.dirname(path.dirname(path.dirname(fileURLToPath(import.meta.url))));
+const CLI = path.join(ROOT, "bin", "go-scaffold.js");
+
+function runCLI(cwd, ...args) {
+  return execFileSync("node", [CLI, ...args], {
+    cwd,
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"],
+  });
+}
+
+function createMigrations(project, table) {
+  return readdirSync(path.join(project, "migrations")).filter((entry) =>
+    entry.includes(`_create_${table}.`)
+  );
+}
+
+test("remove module preserves immutable migrations and re-add reuses them", () => {
+  const scratch = mkdtempSync(path.join(tmpdir(), "go-scaffold-remove-"));
+  try {
+    runCLI(scratch, "create", "sample", "--defaults", "--no-docker");
+    const project = path.join(scratch, "sample");
+    runCLI(project, "generate", "module", "widgets");
+    runCLI(project, "generate", "method", "widgets", "approve", "--type", "patch");
+
+    const before = createMigrations(project, "widgets");
+    assert.equal(before.length, 2);
+    const openapiPath = path.join(project, "docs", "openapi.yaml");
+    assert.match(readFileSync(openapiPath, "utf8"), /\/v1\/widgets\/\{id\}\/approve:/);
+
+    const output = runCLI(project, "remove", "module", "widgets", "--yes");
+
+    assert.equal(existsSync(path.join(project, "internal", "app", "widget")), false);
+    assert.deepEqual(createMigrations(project, "widgets"), before);
+    assert.match(output, /preserved migration history/);
+    assert.match(output, /generate migration drop_widgets/);
+    assert.doesNotMatch(readFileSync(openapiPath, "utf8"), /\.\/widgets\//);
+
+    runCLI(project, "generate", "module", "widgets");
+    assert.deepEqual(createMigrations(project, "widgets"), before);
+  } finally {
+    rmSync(scratch, { recursive: true, force: true });
+  }
+});

package/tests/unit/naming.test.mjs

@@ -0,0 +1,94 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import naming from "../../dist/utils/naming.js";
+
+const { resolveExistingModuleNaming, resolveModuleNaming } = naming;
+
+const cases = [
+  {
+    inputs: ["order", "orders"],
+    expected: {
+      name: "order",
+      pkg: "order",
+      pascalName: "Order",
+      plural: "orders",
+      tableName: "orders",
+      errorPrefix: "ORDER",
+    },
+  },
+  {
+    inputs: ["category", "categories"],
+    expected: {
+      name: "category",
+      pkg: "category",
+      pascalName: "Category",
+      plural: "categories",
+      tableName: "categories",
+      errorPrefix: "CATEGORY",
+    },
+  },
+  {
+    inputs: ["status", "statuses"],
+    expected: {
+      name: "status",
+      pkg: "status",
+      pascalName: "Status",
+      plural: "statuses",
+      tableName: "statuses",
+      errorPrefix: "STATUS",
+    },
+  },
+  {
+    inputs: ["order-item", "order-items"],
+    expected: {
+      name: "order-item",
+      pkg: "orderitem",
+      pascalName: "OrderItem",
+      plural: "order-items",
+      tableName: "order_items",
+      errorPrefix: "ORDER_ITEM",
+    },
+  },
+];
+
+for (const { inputs, expected } of cases) {
+  for (const input of inputs) {
+    test(`resolveModuleNaming normalizes ${input}`, () => {
+      assert.deepEqual(resolveModuleNaming(input), expected);
+    });
+  }
+}
+
+test("resolveExistingModuleNaming finds a pre-canonical plural package", () => {
+  const expected = {
+    name: "orders",
+    pkg: "orders",
+    pascalName: "Orders",
+    plural: "orderses",
+    tableName: "orderses",
+    errorPrefix: "ORDERS",
+  };
+  assert.deepEqual(resolveExistingModuleNaming("orders", ["orders"]), expected);
+  assert.deepEqual(resolveExistingModuleNaming("order", ["orders"]), expected);
+});
+
+test("resolveExistingModuleNaming can locate a legacy package whose singular is now reserved", () => {
+  assert.deepEqual(resolveExistingModuleNaming("types", ["types"]), {
+    name: "types",
+    pkg: "types",
+    pascalName: "Types",
+    plural: "typeses",
+    tableName: "typeses",
+    errorPrefix: "TYPES",
+  });
+});
+
+test("resolveExistingModuleNaming rejects canonical and legacy packages together", () => {
+  for (const input of ["order", "orders"]) {
+    assert.throws(
+      () => resolveExistingModuleNaming(input, ["order", "orders"]),
+      /ambiguous module.*internal\/app\/order.*internal\/app\/orders/
+    );
+  }
+});

package/tests/unit/smoke-isolation.test.mjs

@@ -0,0 +1,35 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { createSmokeRunConfig } from "../../dist/utils/smoke-run.js";
+
+test("smoke runs receive isolated database, app port, database port, log namespace, and resource owner token", () => {
+  const alpha = createSmokeRunConfig("alpha-101", 41001, 54101);
+  const beta = createSmokeRunConfig("beta-202", 41002, 54102);
+
+  assert.match(alpha.dbName, /^go_scaffold_smoke_alpha_101$/);
+  assert.match(beta.dbName, /^go_scaffold_smoke_beta_202$/);
+  assert.notEqual(alpha.dbName, beta.dbName);
+  assert.equal(alpha.dbHost, "127.0.0.1");
+  assert.equal(alpha.dbPort, 54101);
+  assert.equal(beta.dbPort, 54102);
+  assert.notEqual(alpha.dbPort, beta.dbPort);
+  assert.match(alpha.dbDsn, /127\.0\.0\.1:54101\/go_scaffold_smoke_alpha_101\?sslmode=disable$/);
+
+  assert.equal(alpha.port, 41001);
+  assert.equal(beta.port, 41002);
+  assert.notEqual(alpha.baseURL, beta.baseURL);
+  assert.equal(alpha.baseURL, "http://127.0.0.1:41001");
+
+  assert.notEqual(alpha.logPrefix, beta.logPrefix);
+  assert.match(alpha.logPrefix, /go-scaffold-smoke-alpha_101$/);
+  assert.equal(alpha.ownerToken, "go-scaffold-smoke-alpha_101");
+  assert.equal(alpha.dockerLabel, "go-scaffold.smoke.owner=go-scaffold-smoke-alpha_101");
+  assert.equal(alpha.containerNamePrefix, "go-scaffold-smoke-alpha_101");
+  assert.notEqual(alpha.ownerToken, beta.ownerToken);
+});
+
+test("smoke config rejects invalid PostgreSQL ports", () => {
+  assert.throws(() => createSmokeRunConfig("alpha", 41001, 0), /invalid smoke-test PostgreSQL port: 0/);
+  assert.throws(() => createSmokeRunConfig("alpha", 41001, 65536), /invalid smoke-test PostgreSQL port: 65536/);
+});

package/dist/utils/module-paths.js

@@ -1,33 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.listVersionFolders = listVersionFolders;
-exports.versionsContainingModule = versionsContainingModule;
-exports.nextVersionName = nextVersionName;
-const fs_extra_1 = __importDefault(require("fs-extra"));
-const path_1 = __importDefault(require("path"));
-// folder-based domain versioning lays modules out as internal/app/v<n>/<pkg>.
-// listVersionFolders returns the existing v<n> dirs, sorted ascending.
-function listVersionFolders(projectDir) {
-    const appDir = path_1.default.join(projectDir, "internal", "app");
-    if (!fs_extra_1.default.existsSync(appDir))
-        return [];
-    return fs_extra_1.default
-        .readdirSync(appDir, { withFileTypes: true })
-        .filter((e) => e.isDirectory() && /^v\d+$/.test(e.name))
-        .map((e) => e.name)
-        .sort((a, b) => parseInt(a.slice(1), 10) - parseInt(b.slice(1), 10));
-}
-// version folders that actually contain the given module (identified by its
-// handler.go) — a module can legitimately live in more than one version at
-// once (that's the point of versioning), so callers that need exactly one
-// (generate method, remove module) must pick among the matches.
-function versionsContainingModule(projectDir, pkg) {
-    return listVersionFolders(projectDir).filter((v) => fs_extra_1.default.existsSync(path_1.default.join(projectDir, "internal", "app", v, pkg, "handler.go")));
-}
-function nextVersionName(versions) {
-    const max = versions.reduce((m, v) => Math.max(m, parseInt(v.slice(1), 10) || 0), 0);
-    return `v${max + 1}`;
-}