@nakedev/go-scaffold 0.1.4 → 0.3.1

package/templates/add/worker/internal/platform/queue/client.go.hbs

@@ -1,31 +0,0 @@
-package queue
-
-import (
-	"github.com/hibiken/asynq"
-)
-
-// Client enqueues tasks to Redis. Created by cmd/api; each domain or platform
-// package defines its own task types and calls Client.Enqueue.
-type Client struct {
-	inner *asynq.Client
-}
-
-func NewClient(redisURL string) (*Client, error) {
-	opt, err := asynq.ParseRedisURI(redisURL)
-	if err != nil {
-		return nil, err
-	}
-	return &Client{inner: asynq.NewClient(opt)}, nil
-}
-
-func (c *Client) Enqueue(task *asynq.Task, opts ...asynq.Option) (string, error) {
-	info, err := c.inner.Enqueue(task, opts...)
-	if err != nil {
-		return "", err
-	}
-	return info.ID, nil
-}
-
-func (c *Client) Close() error {
-	return c.inner.Close()
-}

package/templates/add/worker/internal/platform/queue/server.go.hbs

@@ -1,68 +0,0 @@
-package queue
-
-import (
-	"context"
-	"fmt"
-	"log/slog"
-
-	"github.com/hibiken/asynq"
-)
-
-// Server runs the background worker. Created by cmd/worker; handlers register
-// their task types on the mux before Start is called.
-type Server struct {
-	inner *asynq.Server
-	mux   *asynq.ServeMux
-}
-
-// slogAdapter wraps *slog.Logger to implement asynq.Logger. Asynq calls these
-// like the stdlib `log` package (a plain message, sometimes several args
-// meant to be concatenated) — fmt.Sprint joins them into one message string
-// rather than passing them as slog key-value pairs, which would otherwise
-// misinterpret a lone message argument as a key with no value.
-type slogAdapter struct {
-	inner *slog.Logger
-}
-
-func (a *slogAdapter) Debug(args ...interface{}) { a.inner.Debug(fmt.Sprint(args...)) }
-func (a *slogAdapter) Info(args ...interface{})  { a.inner.Info(fmt.Sprint(args...)) }
-func (a *slogAdapter) Warn(args ...interface{})  { a.inner.Warn(fmt.Sprint(args...)) }
-func (a *slogAdapter) Error(args ...interface{}) { a.inner.Error(fmt.Sprint(args...)) }
-func (a *slogAdapter) Fatal(args ...interface{}) { a.inner.Error(fmt.Sprint(args...)) }
-
-func NewServer(redisURL string) (*Server, error) {
-	opt, err := asynq.ParseRedisURI(redisURL)
-	if err != nil {
-		return nil, err
-	}
-	srv := &Server{
-		inner: asynq.NewServer(opt, asynq.Config{
-			Concurrency: 10,
-			Logger:      &slogAdapter{inner: slog.Default()},
-		}),
-		mux: asynq.NewServeMux(),
-	}
-	// Global error handler for tasks that panic or return a non-Retryable error.
-	srv.mux.Use(func(next asynq.Handler) asynq.Handler {
-		return asynq.HandlerFunc(func(ctx context.Context, task *asynq.Task) error {
-			err := next.ProcessTask(ctx, task)
-			if err != nil {
-				slog.Error("task failed", "type", task.Type(), "error", err)
-			}
-			return err
-		})
-	})
-	return srv, nil
-}
-
-func (s *Server) Handle(pattern string, handler asynq.Handler) {
-	s.mux.Handle(pattern, handler)
-}
-
-func (s *Server) Start() error {
-	return s.inner.Start(s.mux)
-}
-
-func (s *Server) Shutdown() {
-	s.inner.Shutdown()
-}

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

@@ -1,46 +0,0 @@
-import assert from "node:assert/strict";
-import { execFileSync } from "node:child_process";
-import { existsSync, mkdtempSync, readFileSync, 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"],
-  });
-}
-
-test("generate module defaults to a safe minimal module", () => {
-  const scratch = mkdtempSync(path.join(tmpdir(), "go-scaffold-default-module-"));
-  try {
-    runCLI(scratch, "create", "sample", "--defaults", "--no-docker");
-    const project = path.join(scratch, "sample");
-
-    const output = runCLI(project, "generate", "module", "orders");
-    const handler = readFileSync(
-      path.join(project, "internal", "app", "order", "handler.go"),
-      "utf8"
-    );
-
-    assert.match(output, /registered empty route group/);
-    assert.doesNotMatch(handler, /g\.POST\(/);
-    assert.equal(existsSync(path.join(project, "docs", "orders")), false);
-
-    const legacyOutput = runCLI(project, "generate", "module", "widgets", "--no-full");
-    const legacyHandler = readFileSync(
-      path.join(project, "internal", "app", "widget", "handler.go"),
-      "utf8"
-    );
-    assert.match(legacyOutput, /registered empty route group/);
-    assert.doesNotMatch(legacyHandler, /g\.POST\(/);
-  } finally {
-    rmSync(scratch, { recursive: true, force: true });
-  }
-});

package/tests/integration/generator-naming.test.mjs

@@ -1,81 +0,0 @@
-import assert from "node:assert/strict";
-import { execFileSync } from "node:child_process";
-import {
-  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 read(root, relativePath) {
-  return readFileSync(path.join(root, relativePath), "utf8");
-}
-
-function migration(root, suffix) {
-  const filename = readdirSync(path.join(root, "migrations")).find((entry) =>
-    entry.endsWith(suffix)
-  );
-  assert.ok(filename, `missing migration ending with ${suffix}`);
-  return read(root, path.join("migrations", filename));
-}
-
-test("plural module input produces a singular entity with one explicit table name", () => {
-  const scratch = mkdtempSync(path.join(tmpdir(), "go-scaffold-naming-"));
-  try {
-    runCLI(scratch, "create", "sample", "--defaults", "--no-docker");
-    const project = path.join(scratch, "sample");
-    runCLI(project, "generate", "module", "orders");
-
-    const model = read(project, "internal/app/order/model/model.go");
-    assert.match(model, /type Order struct/);
-    assert.match(
-      model,
-      /func \(Order\) TableName\(\) string \{\s*return "orders"\s*\}/
-    );
-    assert.match(migration(project, "_create_orders.up.sql"), /CREATE TABLE orders/);
-    assert.match(read(project, "internal/app/order/handler.go"), /Group\("\/orders"/);
-  } finally {
-    rmSync(scratch, { recursive: true, force: true });
-  }
-});
-
-test("multi-word module keeps URL words and uses snake_case SQL identifiers", () => {
-  const scratch = mkdtempSync(path.join(tmpdir(), "go-scaffold-multiword-"));
-  try {
-    runCLI(scratch, "create", "sample", "--defaults", "--no-docker");
-    const project = path.join(scratch, "sample");
-    runCLI(project, "generate", "module", "order-items");
-
-    const model = read(project, "internal/app/orderitem/model/model.go");
-    assert.match(model, /type OrderItem struct/);
-    assert.match(
-      model,
-      /func \(OrderItem\) TableName\(\) string \{\s*return "order_items"\s*\}/
-    );
-    assert.match(
-      migration(project, "_create_order-items.up.sql"),
-      /CREATE TABLE order_items/
-    );
-    assert.match(
-      read(project, "internal/app/orderitem/handler.go"),
-      /Group\("\/order-items"/
-    );
-  } finally {
-    rmSync(scratch, { recursive: true, force: true });
-  }
-});

package/tests/integration/generator-unit-test-seams.test.mjs

@@ -1,91 +0,0 @@
-import assert from "node:assert/strict";
-import { execFileSync } from "node:child_process";
-import { mkdtempSync, readFileSync, 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 run(command, args, cwd) {
-  return execFileSync(command, args, {
-    cwd,
-    encoding: "utf8",
-    stdio: ["ignore", "pipe", "pipe"],
-  });
-}
-
-function read(project, relativePath) {
-  return readFileSync(path.join(project, relativePath), "utf8");
-}
-
-test("generated modules have scalable service and handler unit-test seams", () => {
-  const scratch = mkdtempSync(path.join(tmpdir(), "go-scaffold-unit-seams-"));
-  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 handler = read(project, "internal/app/order/handler.go");
-    assert.match(handler, /type service interface \{/);
-    assert.match(handler, /svc service/);
-    assert.doesNotMatch(handler, /svc \*Service/);
-    assert.match(handler, /Create\(context\.Context, createInput\)/);
-    assert.match(handler, /Update\(context\.Context, uuid\.UUID, updateInput\)/);
-
-    const service = read(project, "internal/app/order/service.go");
-    assert.match(service, /Create\(ctx context\.Context, in createInput\)/);
-    assert.match(service, /Update\(ctx context\.Context, id uuid\.UUID, in updateInput\)/);
-
-    const serviceTest = read(project, "internal/app/order/service_test.go");
-    assert.match(serviceTest, /type repositoryStub struct/);
-    assert.match(serviceTest, /createFn\s+func/);
-    assert.match(serviceTest, /findByIDFn\s+func/);
-    assert.match(serviceTest, /updateFn\s+func/);
-    assert.doesNotMatch(serviceTest, /type fakeRepo struct/);
-
-    const handlerTest = read(project, "internal/app/order/handler_test.go");
-    assert.match(handlerTest, /type serviceStub struct/);
-    assert.match(handlerTest, /createFn\s+func/);
-    assert.doesNotMatch(handlerTest, /gorm\.io\/driver\/postgres/);
-    assert.doesNotMatch(handlerTest, /TEST_DB_DSN/);
-
-    const repositoryTest = read(project, "internal/app/order/repository_test.go");
-    assert.match(repositoryTest, /REQUIRE_TEST_DB/);
-    assert.match(repositoryTest, /TEST_DB_DSN/);
-    assert.doesNotMatch(repositoryTest, /AutoMigrate/);
-    assert.doesNotMatch(repositoryTest, /DropTable/);
-
-    const ci = read(project, ".github/workflows/ci.yml");
-    assert.match(ci, /migrate -path migrations/);
-    assert.match(ci, /REQUIRE_TEST_DB: "true"/);
-    assert.match(ci, /TEST_DB_DSN:/);
-
-    const itemDocs = read(project, "docs/orders/item.yaml");
-    const deleteContract = itemDocs.slice(itemDocs.indexOf("delete:"));
-    assert.doesNotMatch(deleteContract, /"404"/);
-
-    run("node", [CLI, "generate", "method", "orders", "approve", "--type", "patch"], project);
-    const openapi = read(project, "docs/openapi.yaml");
-    assert.match(openapi, /\/v1\/orders\/\{id\}\/approve:/);
-    const approveDocs = read(project, "docs/orders/methods/approve.yaml");
-    assert.match(approveDocs, /^parameters:/);
-    assert.match(approveDocs, /^patch:/m);
-    assert.match(approveDocs, /operationId: approveOrder/);
-    assert.doesNotMatch(approveDocs, /requestBody:/);
-
-    run("node", [CLI, "generate", "method", "orders", "submit", "--type", "post"], project);
-    const submitDocs = read(project, "docs/orders/methods/submit.yaml");
-    assert.doesNotMatch(submitDocs, /^parameters:/);
-    assert.doesNotMatch(submitDocs, /in: path/);
-    assert.match(submitDocs, /^post:/m);
-    assert.match(submitDocs, /requestBody:/);
-
-    run("go", ["mod", "tidy"], project);
-    run("go", ["test", "./..."], project);
-  } finally {
-    rmSync(scratch, { recursive: true, force: true });
-  }
-});

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

@@ -1,222 +0,0 @@
-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

@@ -1,58 +0,0 @@
-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 });
-  }
-});