@danceroutine/tango-codegen 0.1.0 → 1.0.0

package/dist/frameworks-Bp_9BOt2.js

@@ -0,0 +1,1366 @@
+import { __export } from "./chunk-BkvOhyD0.js";
+import { mkdir, readdir, stat, writeFile } from "node:fs/promises";
+import { dirname, isAbsolute, resolve } from "node:path";
+
+//#region src/frameworks/contracts/template/ScaffoldTemplate.ts
+const SCAFFOLD_TEMPLATE_CATEGORY = {
+	FRAMEWORK: "framework",
+	TANGO: "tango",
+	INIT_ONLY: "init-only"
+};
+
+//#endregion
+//#region src/frameworks/contracts/template/implementation/ScaffoldTemplateDescriptor.ts
+var ScaffoldTemplateDescriptor = class {
+	constructor(template, category) {
+		this.template = template;
+		this.category = category;
+	}
+	get path() {
+		return this.template.getPath();
+	}
+	render(ctx) {
+		return this.template.setContext(ctx).build();
+	}
+	shouldEmit(mode) {
+		if (mode === "new") return this.category === SCAFFOLD_TEMPLATE_CATEGORY.FRAMEWORK || this.category === SCAFFOLD_TEMPLATE_CATEGORY.TANGO;
+		return this.category === SCAFFOLD_TEMPLATE_CATEGORY.TANGO || this.category === SCAFFOLD_TEMPLATE_CATEGORY.INIT_ONLY;
+	}
+};
+
+//#endregion
+//#region package.json
+var name = "@danceroutine/tango-codegen";
+var version$1 = "1.0.0";
+var description = "CLI for generating repositories, types, migrations, and OpenAPI specs for Tango";
+var type = "module";
+var main = "./dist/index.js";
+var types = "./dist/index.d.ts";
+var exports = {
+	".": {
+		"types": "./dist/index.d.ts",
+		"import": "./dist/index.js"
+	},
+	"./domain": {
+		"types": "./dist/domain/index.d.ts",
+		"import": "./dist/domain/index.js"
+	},
+	"./generators": {
+		"types": "./dist/generators/index.d.ts",
+		"import": "./dist/generators/index.js"
+	},
+	"./frameworks": {
+		"types": "./dist/frameworks/index.d.ts",
+		"import": "./dist/frameworks/index.js"
+	},
+	"./commands": {
+		"types": "./dist/commands/index.d.ts",
+		"import": "./dist/commands/index.js"
+	}
+};
+var files = ["dist"];
+var scripts = {
+	"build": "tsdown",
+	"test": "vitest run --coverage",
+	"test:watch": "vitest",
+	"typecheck": "pnpm run typecheck:prod && pnpm run typecheck:test",
+	"typecheck:prod": "tsc --noEmit -p tsconfig.json",
+	"typecheck:test": "tsc --noEmit -p tsconfig.tests.json"
+};
+var keywords = [
+	"tango",
+	"codegen",
+	"cli",
+	"generator",
+	"migrations"
+];
+var author = "Pedro Del Moral Lopez";
+var license = "MIT";
+var repository = {
+	"type": "git",
+	"url": "https://github.com/danceroutine/tango.git",
+	"directory": "packages/codegen"
+};
+var dependencies = {
+	"@danceroutine/tango-core": "workspace:*",
+	"yargs": "^17.7.2"
+};
+var devDependencies = {
+	"@types/yargs": "^17.0.33",
+	"@types/node": "^22.9.0",
+	"tsdown": "^0.4.0",
+	"typescript": "^5.6.3",
+	"vitest": "^4.0.6"
+};
+var package_default = {
+	name,
+	version: version$1,
+	description,
+	type,
+	main,
+	types,
+	exports,
+	files,
+	scripts,
+	keywords,
+	author,
+	license,
+	repository,
+	dependencies,
+	devDependencies
+};
+
+//#endregion
+//#region src/frameworks/contracts/template/TemplateBuilder.ts
+const { version } = package_default;
+var TemplateBuilder = class TemplateBuilder {
+	name;
+	_context;
+	constructor(options) {
+		this.name = options.name;
+	}
+	/**
+	* One-liner to install Tango + dialect deps and Tango CLI (for init success message).
+	*/
+	static getTangoInstallOneLiner(packageManager, dialect, framework) {
+		const deps = TemplateBuilder.getTangoDependencyEntriesFor(dialect, framework);
+		const devDeps = TemplateBuilder.getTangoDevDependencyEntriesFor();
+		const depList = Object.entries(deps).map(([pkg, ver]) => `${pkg}@${ver}`).join(" ");
+		const devList = Object.entries(devDeps).map(([pkg, ver]) => `${pkg}@${ver}`).join(" ");
+		const addCmd = packageManager === "npm" ? "npm install" : `${packageManager} add`;
+		const addDevCmd = packageManager === "npm" ? "npm install -D" : `${packageManager} add -D`;
+		return `${addCmd} ${depList} && ${addDevCmd} ${devList}`;
+	}
+	/**
+	* Shorthand for static content (no subclass needed). Returns a BoundTemplate that add* methods accept.
+	*/
+	static createStaticTemplate(fileName, template) {
+		class TransientStaticTemplateBuilder extends TemplateBuilder {
+			resolveTemplate(_context) {
+				return typeof template === "string" ? template : template();
+			}
+		}
+		return new TransientStaticTemplateBuilder({ name: fileName });
+	}
+	/** Tango package version (semver range) for scaffolded dependency entries. */
+	static getTangoVersion() {
+		return `^${version}`;
+	}
+	static getTangoDependencyEntriesFor(dialect, framework) {
+		const v = TemplateBuilder.getTangoVersion();
+		const core = {
+			"@danceroutine/tango-core": v,
+			"@danceroutine/tango-schema": v,
+			"@danceroutine/tango-orm": v,
+			"@danceroutine/tango-resources": v,
+			"@danceroutine/tango-migrations": v,
+			"@danceroutine/tango-openapi": v,
+			"@danceroutine/tango-config": v
+		};
+		const adapter = framework === "express" ? { "@danceroutine/tango-adapters-express": v } : { "@danceroutine/tango-adapters-next": v };
+		const dialectDeps = dialect === "sqlite" ? { "better-sqlite3": "^11.10.0" } : { pg: "^8.16.3" };
+		return {
+			...core,
+			...adapter,
+			...dialectDeps
+		};
+	}
+	static getTangoDevDependencyEntriesFor() {
+		return { "@danceroutine/tango-cli": TemplateBuilder.getTangoVersion() };
+	}
+	/** Bind context and return this for chaining. Use before passing to add* methods. */
+	setContext(context) {
+		this._context = context;
+		return this;
+	}
+	getPath() {
+		return this.name;
+	}
+	build() {
+		if (this._context === undefined) throw new Error("TemplateBuilder: context not bound. Call .setContext(context) before .build().");
+		return this.resolveTemplate(this._context);
+	}
+	getTangoDependencyEntries(context) {
+		return TemplateBuilder.getTangoDependencyEntriesFor(context.dialect, context.framework);
+	}
+	getTangoDevDependencyEntries(_context) {
+		return TemplateBuilder.getTangoDevDependencyEntriesFor();
+	}
+};
+
+//#endregion
+//#region src/frameworks/contracts/FrameworkScaffoldStrategy.ts
+const SUPPORTED_FRAMEWORK = {
+	EXPRESS: "express",
+	NEXT: "next"
+};
+const PACKAGE_MANAGER = {
+	PNPM: "pnpm",
+	NPM: "npm",
+	YARN: "yarn",
+	BUN: "bun"
+};
+const SCAFFOLD_DATABASE_DIALECT = {
+	SQLITE: "sqlite",
+	POSTGRES: "postgres"
+};
+var FrameworkScaffoldStrategy = class {
+	/**
+	* One-liner to install Tango + dialect deps and Tango CLI, for init success message.
+	*/
+	getTangoInstallOneLiner(packageManager, context) {
+		return TemplateBuilder.getTangoInstallOneLiner(packageManager, context.dialect, context.framework);
+	}
+	addFrameworkTemplate(template) {
+		return this.createTemplate(template, SCAFFOLD_TEMPLATE_CATEGORY.FRAMEWORK);
+	}
+	addTangoTemplate(template) {
+		return this.createTemplate(template, SCAFFOLD_TEMPLATE_CATEGORY.TANGO);
+	}
+	addInitOnlyTemplate(template) {
+		return this.createTemplate(template, SCAFFOLD_TEMPLATE_CATEGORY.INIT_ONLY);
+	}
+	createTemplate(template, category) {
+		return new ScaffoldTemplateDescriptor(template, category);
+	}
+};
+
+//#endregion
+//#region src/frameworks/strategies/express/templates/packageJson.ts
+var PackageJsonTemplateBuilder$1 = class extends TemplateBuilder {
+	constructor() {
+		super({ name: "package.json" });
+	}
+	resolveTemplate(context) {
+		const deps = this.getTangoDependencyEntries(context);
+		const devDeps = this.getTangoDevDependencyEntries(context);
+		return JSON.stringify({
+			name: context.projectName,
+			private: true,
+			type: "module",
+			scripts: {
+				predev: "tango migrate --config ./tango.config.ts",
+				dev: "tsx watch src/index.ts",
+				prestart: "tango migrate --config ./tango.config.ts",
+				build: "tsc -p tsconfig.build.json",
+				start: "node dist/index.js",
+				typecheck: "tsc --noEmit",
+				"setup:schema": "node -e \"require('node:fs').mkdirSync('./.data',{recursive:true})\" && tango migrate --config ./tango.config.ts",
+				"make:migrations": "tango make:migrations --config ./tango.config.ts --models ./src/models/index.ts --name \"\${npm_config_name:-manual_change}\"",
+				prebootstrap: "node -e \"require('node:fs').mkdirSync('./.data',{recursive:true})\" && tango migrate --config ./tango.config.ts",
+				bootstrap: "tsx src/bootstrap.ts"
+			},
+			dependencies: {
+				...deps,
+				express: "^4.21.2",
+				zod: "^4.0.0"
+			},
+			devDependencies: {
+				...devDeps,
+				"@types/express": "^5.0.0",
+				"@types/node": "^22.9.0",
+				tsx: "^4.20.6",
+				typescript: "^5.6.3"
+			}
+		}, null, 4);
+	}
+};
+
+//#endregion
+//#region src/frameworks/strategies/express/templates/tsconfig.ts
+var TsConfigTemplateBuilder$1 = class extends TemplateBuilder {
+	constructor() {
+		super({ name: "tsconfig.json" });
+	}
+	resolveTemplate(_context) {
+		return JSON.stringify({
+			compilerOptions: {
+				target: "ES2022",
+				lib: ["ES2022", "DOM"],
+				module: "NodeNext",
+				moduleResolution: "NodeNext",
+				strict: true,
+				noEmit: true,
+				esModuleInterop: true,
+				skipLibCheck: true,
+				resolveJsonModule: true,
+				types: ["node"]
+			},
+			include: [
+				"src",
+				"migrations/**/*.ts",
+				"tango.config.ts"
+			],
+			exclude: ["node_modules", "dist"]
+		}, null, 4);
+	}
+};
+
+//#endregion
+//#region src/frameworks/strategies/express/templates/tsconfigBuild.ts
+var TsConfigBuildTemplateBuilder = class extends TemplateBuilder {
+	constructor() {
+		super({ name: "tsconfig.build.json" });
+	}
+	resolveTemplate(_context) {
+		return JSON.stringify({
+			extends: "./tsconfig.json",
+			compilerOptions: {
+				noEmit: false,
+				outDir: "./dist",
+				rootDir: ".",
+				sourceMap: true,
+				declaration: false
+			},
+			include: ["src", "tango.config.ts"],
+			exclude: [
+				"node_modules",
+				"dist",
+				"migrations",
+				"**/*.test.ts"
+			]
+		}, null, 4);
+	}
+};
+
+//#endregion
+//#region src/frameworks/strategies/express/templates/tangoConfig.ts
+var TangoConfigTemplateBuilder$1 = class extends TemplateBuilder {
+	constructor() {
+		super({ name: "tango.config.ts" });
+	}
+	resolveTemplate(context) {
+		if (context.dialect === "sqlite") return `import { defineConfig } from '@danceroutine/tango-config';
+
+export default defineConfig({
+    current: (process.env.NODE_ENV || 'development') as 'development' | 'test' | 'production',
+    environments: {
+        development: {
+            name: 'development',
+            db: {
+                adapter: 'sqlite',
+                filename: process.env.TANGO_SQLITE_FILENAME || './.data/${context.projectName}.sqlite',
+                maxConnections: 1,
+            },
+            migrations: { dir: './migrations', online: false },
+        },
+        test: {
+            name: 'test',
+            db: {
+                adapter: 'sqlite',
+                filename: process.env.TANGO_SQLITE_FILENAME || ':memory:',
+                maxConnections: 1,
+            },
+            migrations: { dir: './migrations', online: false },
+        },
+        production: {
+            name: 'production',
+            db: {
+                adapter: 'sqlite',
+                filename: process.env.TANGO_SQLITE_FILENAME || './.data/${context.projectName}.sqlite',
+                maxConnections: 1,
+            },
+            migrations: { dir: './migrations', online: false },
+        },
+    },
+});
+`;
+		return `import { defineConfig } from '@danceroutine/tango-config';
+
+export default defineConfig({
+    current: (process.env.NODE_ENV || 'development') as 'development' | 'test' | 'production',
+    environments: {
+        development: {
+            name: 'development',
+            db: {
+                adapter: 'postgres',
+                url: process.env.TANGO_DATABASE_URL || 'postgres://postgres:postgres@localhost:5432/${context.projectName}',
+                maxConnections: 10,
+            },
+            migrations: { dir: './migrations', online: true },
+        },
+        test: {
+            name: 'test',
+            db: {
+                adapter: 'postgres',
+                url: process.env.TANGO_DATABASE_URL || 'postgres://postgres:postgres@localhost:5432/${context.projectName}_test',
+                maxConnections: 5,
+            },
+            migrations: { dir: './migrations', online: true },
+        },
+        production: {
+            name: 'production',
+            db: {
+                adapter: 'postgres',
+                url: process.env.TANGO_DATABASE_URL || 'postgres://postgres:postgres@localhost:5432/${context.projectName}',
+                maxConnections: 20,
+            },
+            migrations: { dir: './migrations', online: true },
+        },
+    },
+});
+`;
+	}
+};
+
+//#endregion
+//#region src/frameworks/strategies/express/templates/appSource.ts
+var AppSourceTemplateBuilder = class extends TemplateBuilder {
+	constructor() {
+		super({ name: "src/index.ts" });
+	}
+	resolveTemplate(_context) {
+		return `import express from 'express';
+import { seedExampleData } from './bootstrap.js';
+import { registerTango } from './tango.js';
+
+async function main(): Promise<void> {
+    const app = express();
+    app.use(express.json());
+
+    if (process.env.AUTO_BOOTSTRAP === 'true') {
+        await seedExampleData(Number(process.env.SEED_TODOS_COUNT || '100'));
+    }
+
+    app.get('/health', (_req, res) => {
+        res.json({ ok: true });
+    });
+
+    await registerTango(app);
+
+    const port = Number(process.env.PORT || '3000');
+    app.listen(port, () => {
+        console.log(\`Tango Express app listening on http://localhost:\${String(port)}\`);
+    });
+}
+
+// oxlint-disable-next-line unicorn/prefer-top-level-await
+main().catch((error: unknown) => {
+    console.error('Failed to start app:', error);
+    process.exit(1);
+});
+`;
+	}
+};
+
+//#endregion
+//#region src/frameworks/strategies/express/templates/models.ts
+var TodoModelTemplateBuilder$1 = class extends TemplateBuilder {
+	constructor() {
+		super({ name: "src/models/TodoModel.ts" });
+	}
+	resolveTemplate(_context) {
+		return `import { z } from 'zod';
+import '@danceroutine/tango-orm/runtime';
+import { Model, t } from '@danceroutine/tango-schema';
+
+export const TodoReadSchema = z.object({
+    id: z.number(),
+    title: z.string().min(1),
+    completed: z.coerce.boolean(),
+    createdAt: z.string(),
+    updatedAt: z.string(),
+});
+
+export const TodoCreateSchema = z.object({
+    title: z.string().min(1),
+    completed: z.boolean().optional().default(false),
+});
+
+export const TodoUpdateSchema = TodoCreateSchema.partial();
+
+export type Todo = z.output<typeof TodoReadSchema>;
+
+export const TodoModel = Model({
+    namespace: 'app',
+    name: 'Todo',
+    schema: TodoReadSchema.extend({
+        id: t.primaryKey(z.number().int()),
+        title: z.string().min(1),
+        completed: t.default(z.coerce.boolean(), 'false'),
+        createdAt: t.default(z.string(), { now: true }),
+        updatedAt: t.default(z.string(), { now: true }),
+    }),
+});
+`;
+	}
+};
+var ModelsBarrelTemplateBuilder$1 = class extends TemplateBuilder {
+	constructor() {
+		super({ name: "src/models/index.ts" });
+	}
+	resolveTemplate(_context) {
+		return `export { TodoReadSchema, TodoCreateSchema, TodoUpdateSchema, TodoModel, type Todo } from './TodoModel.js';
+`;
+	}
+};
+
+//#endregion
+//#region src/frameworks/strategies/express/templates/serializers.ts
+var TodoSerializerTemplateBuilder$1 = class extends TemplateBuilder {
+	constructor() {
+		super({ name: "src/serializers/TodoSerializer.ts" });
+	}
+	resolveTemplate(_context) {
+		return `import { ModelSerializer } from '@danceroutine/tango-resources';
+import { TodoCreateSchema, TodoModel, TodoReadSchema, TodoUpdateSchema, type Todo } from '../models/index.js';
+
+export class TodoSerializer extends ModelSerializer<
+    Todo,
+    typeof TodoCreateSchema,
+    typeof TodoUpdateSchema,
+    typeof TodoReadSchema
+> {
+    static readonly model = TodoModel;
+    static readonly createSchema = TodoCreateSchema;
+    static readonly updateSchema = TodoUpdateSchema;
+    static readonly outputSchema = TodoReadSchema;
+}
+`;
+	}
+};
+var SerializersBarrelTemplateBuilder$1 = class extends TemplateBuilder {
+	constructor() {
+		super({ name: "src/serializers/index.ts" });
+	}
+	resolveTemplate(_context) {
+		return `export { TodoSerializer } from './TodoSerializer.js';
+`;
+	}
+};
+
+//#endregion
+//#region src/frameworks/strategies/express/templates/openapi.ts
+var OpenAPITemplateBuilder$1 = class extends TemplateBuilder {
+	constructor() {
+		super({ name: "src/openapi.ts" });
+	}
+	resolveTemplate(_context) {
+		return `import { describeViewSet, generateOpenAPISpec, type OpenAPISpec } from '@danceroutine/tango-openapi';
+import { TodoViewSet } from './viewsets/TodoViewSet.js';
+
+export function createOpenAPISpec(): OpenAPISpec {
+    return generateOpenAPISpec({
+        title: 'Tango Express Todo API',
+        version: '1.0.0',
+        description: 'OpenAPI document generated from Tango resource instances.',
+        resources: [describeViewSet({ basePath: '/api/todos', resource: new TodoViewSet() })],
+    });
+}
+`;
+	}
+};
+
+//#endregion
+//#region src/frameworks/strategies/express/templates/viewSet.ts
+var ViewSetTemplateBuilder$1 = class extends TemplateBuilder {
+	constructor() {
+		super({ name: "src/viewsets/TodoViewSet.ts" });
+	}
+	resolveTemplate(_context) {
+		return `import { FilterSet, ModelViewSet } from '@danceroutine/tango-resources';
+import { type Todo } from '../models/index.js';
+import { TodoSerializer } from '../serializers/index.js';
+
+export class TodoViewSet extends ModelViewSet<Todo, typeof TodoSerializer> {
+    constructor() {
+        super({
+            serializer: TodoSerializer,
+            filters: FilterSet.define<Todo>({
+                fields: {
+                    completed: true,
+                },
+                aliases: {
+                    q: { fields: ['title'], lookup: 'icontains' },
+                },
+            }),
+            orderingFields: ['id', 'createdAt', 'updatedAt', 'title'],
+            searchFields: ['title'],
+        });
+    }
+}
+`;
+	}
+};
+
+//#endregion
+//#region src/frameworks/strategies/express/templates/bootstrap.ts
+var BootstrapTemplateBuilder$1 = class extends TemplateBuilder {
+	constructor() {
+		super({ name: "src/bootstrap.ts" });
+	}
+	resolveTemplate(_context) {
+		return `import { TodoModel, type Todo } from './models/index.js';
+
+export async function seedExampleData(count = 100): Promise<void> {
+    const existing = await TodoModel.objects.query().count();
+    if (existing >= count) {
+        console.log(\`[bootstrap] Skipped; already have \${existing} todos.\`);
+        return;
+    }
+
+    const rows: Array<Partial<Todo>> = [];
+    for (let index = existing; index < count; index += 1) {
+        const now = new Date(Date.now() - index * 60_000).toISOString();
+        rows.push({
+            title: \`Seeded todo #\${index + 1}\`,
+            completed: index % 3 === 0,
+            createdAt: now,
+            updatedAt: now,
+        });
+    }
+
+    await TodoModel.objects.bulkCreate(rows);
+    console.log(\`[bootstrap] Seeded \${rows.length} todos.\`);
+}
+
+if (import.meta.url === \`file://\${process.argv[1]}\`) {
+    const count = Number(process.env.SEED_TODOS_COUNT || '100');
+    // oxlint-disable-next-line unicorn/prefer-top-level-await
+    seedExampleData(Number.isFinite(count) ? count : 100).catch((error: unknown) => {
+        console.error('[bootstrap] Failed:', error);
+        process.exit(1);
+    });
+}
+`;
+	}
+};
+
+//#endregion
+//#region src/frameworks/strategies/express/templates/readme.ts
+var ReadmeTemplateBuilder$1 = class extends TemplateBuilder {
+	constructor() {
+		super({ name: "README.md" });
+	}
+	resolveTemplate(context) {
+		return `# ${context.projectName}
+
+This project was scaffolded by \`tango new --framework express\`.
+
+Express still owns the server and route registration; Tango owns model metadata, \`Model.objects\`, serializers, migrations, querying, and resource behavior.
+
+## First-time setup
+
+Generate your first migration from the scaffolded models, then start the app:
+
+\`\`\`bash
+${context.packageManager} run make:migrations --name initial
+${context.packageManager} run dev
+\`\`\`
+
+## Scripts
+
+- \`${context.packageManager} run dev\`
+- \`${context.packageManager} run make:migrations --name add_field\`
+- \`${context.packageManager} run setup:schema\`
+- \`${context.packageManager} run bootstrap\`
+- \`${context.packageManager} run typecheck\`
+
+## Useful endpoints
+
+- \`GET /health\`
+- \`GET /api/openapi.json\`
+- \`GET|POST|PATCH|DELETE /api/todos...\`
+
+## Project layout
+
+- \`tango.config.ts\` Tango configuration
+- \`src/tango.ts\` Express registration helper for Tango routes
+- \`src/models/\` schemas and Tango model metadata; importing the model module enables \`Model.objects\`
+- \`src/serializers/\` serializer-backed API contracts for Tango resources
+- \`src/viewsets/\` CRUD resources backed by \`Model.objects\`
+- \`src/openapi.ts\` OpenAPI document generation
+- \`src/bootstrap.ts\` seed utility for a larger demo dataset
+- \`migrations/\` checked-in Tango migrations
+`;
+	}
+};
+
+//#endregion
+//#region src/frameworks/strategies/express/templates/tangoRegister.ts
+var TangoRegisterTemplateBuilder = class extends TemplateBuilder {
+	constructor() {
+		super({ name: "src/tango.ts" });
+	}
+	resolveTemplate(_context) {
+		return `import type { Application } from 'express';
+import { ExpressAdapter } from '@danceroutine/tango-adapters-express/adapter';
+import { createOpenAPISpec } from './openapi.js';
+import { TodoViewSet } from './viewsets/TodoViewSet.js';
+
+/**
+ * Register Tango API routes and OpenAPI spec on an existing Express app.
+ * Use from your app entry (for example, \`index.ts\`): \`await registerTango(app);\`
+ */
+export async function registerTango(app: Application): Promise<void> {
+    const adapter = new ExpressAdapter();
+    adapter.registerViewSet(app, '/api/todos', new TodoViewSet());
+    app.get('/api/openapi.json', (_req, res) => {
+        res.json(createOpenAPISpec());
+    });
+}
+`;
+	}
+};
+
+//#endregion
+//#region src/frameworks/strategies/express/ExpressScaffoldStrategy.ts
+var ExpressScaffoldStrategy = class extends FrameworkScaffoldStrategy {
+	id = "express";
+	name = "Express";
+	description = "Bootstrap a Tango application hosted by Express.";
+	/**
+	* Return the file templates needed for the generated Express project.
+	*/
+	getTemplates() {
+		return [
+			this.addFrameworkTemplate(new PackageJsonTemplateBuilder$1()),
+			this.addFrameworkTemplate(new TsConfigTemplateBuilder$1()),
+			this.addFrameworkTemplate(new TsConfigBuildTemplateBuilder()),
+			this.addTangoTemplate(new TangoConfigTemplateBuilder$1()),
+			this.addFrameworkTemplate(new AppSourceTemplateBuilder()),
+			this.addTangoTemplate(new TodoModelTemplateBuilder$1()),
+			this.addTangoTemplate(new ModelsBarrelTemplateBuilder$1()),
+			this.addTangoTemplate(new TodoSerializerTemplateBuilder$1()),
+			this.addTangoTemplate(new SerializersBarrelTemplateBuilder$1()),
+			this.addTangoTemplate(new OpenAPITemplateBuilder$1()),
+			this.addTangoTemplate(new ViewSetTemplateBuilder$1()),
+			this.addTangoTemplate(new BootstrapTemplateBuilder$1()),
+			this.addFrameworkTemplate(TemplateBuilder.createStaticTemplate("migrations/.gitkeep", "")),
+			this.addFrameworkTemplate(new ReadmeTemplateBuilder$1()),
+			this.addFrameworkTemplate(TemplateBuilder.createStaticTemplate(".gitignore", "node_modules\ndist\n.data\n.env\n")),
+			this.addTangoTemplate(new TangoRegisterTemplateBuilder())
+		];
+	}
+};
+
+//#endregion
+//#region src/frameworks/strategies/next/templates/packageJson.ts
+var PackageJsonTemplateBuilder = class extends TemplateBuilder {
+	constructor() {
+		super({ name: "package.json" });
+	}
+	resolveTemplate(context) {
+		const deps = this.getTangoDependencyEntries(context);
+		const devDeps = this.getTangoDevDependencyEntries(context);
+		return JSON.stringify({
+			name: context.projectName,
+			private: true,
+			type: "module",
+			scripts: {
+				predev: "tango migrate --config ./tango.config.ts",
+				dev: "next dev",
+				prestart: "tango migrate --config ./tango.config.ts",
+				build: "next build",
+				start: "next start",
+				typecheck: "tsc --noEmit",
+				"setup:schema": "node -e \"require('node:fs').mkdirSync('./.data',{recursive:true})\" && tango migrate --config ./tango.config.ts",
+				"make:migrations": "tango make:migrations --config ./tango.config.ts --models ./src/lib/models/index.ts --name \"\${npm_config_name:-manual_change}\"",
+				prebootstrap: "node -e \"require('node:fs').mkdirSync('./.data',{recursive:true})\" && tango migrate --config ./tango.config.ts",
+				bootstrap: "tsx scripts/bootstrap.ts"
+			},
+			dependencies: {
+				...deps,
+				next: "^15.1.6",
+				react: "^19.0.0",
+				"react-dom": "^19.0.0",
+				zod: "^4.0.0"
+			},
+			devDependencies: {
+				...devDeps,
+				"@types/node": "^22.9.0",
+				"@types/react": "^19.0.6",
+				"@types/react-dom": "^19.0.2",
+				tsx: "^4.20.6",
+				typescript: "^5.6.3"
+			}
+		}, null, 4);
+	}
+};
+
+//#endregion
+//#region src/frameworks/strategies/next/templates/tsconfig.ts
+var TsConfigTemplateBuilder = class extends TemplateBuilder {
+	constructor() {
+		super({ name: "tsconfig.json" });
+	}
+	resolveTemplate(_context) {
+		return JSON.stringify({
+			compilerOptions: {
+				target: "ES2022",
+				lib: [
+					"dom",
+					"dom.iterable",
+					"es2022"
+				],
+				strict: true,
+				noEmit: true,
+				module: "esnext",
+				moduleResolution: "bundler",
+				resolveJsonModule: true,
+				isolatedModules: true,
+				jsx: "preserve",
+				esModuleInterop: true,
+				baseUrl: ".",
+				paths: { "@/*": ["src/*"] }
+			},
+			include: [
+				"next-env.d.ts",
+				"**/*.ts",
+				"**/*.tsx",
+				"migrations/**/*.ts"
+			],
+			exclude: ["node_modules"]
+		}, null, 4);
+	}
+};
+
+//#endregion
+//#region src/frameworks/strategies/next/templates/tangoConfig.ts
+var TangoConfigTemplateBuilder = class extends TemplateBuilder {
+	constructor() {
+		super({ name: "tango.config.ts" });
+	}
+	resolveTemplate(context) {
+		if (context.dialect === "sqlite") return `import { defineConfig } from '@danceroutine/tango-config';
+
+export default defineConfig({
+    current: (process.env.NODE_ENV || 'development') as 'development' | 'test' | 'production',
+    environments: {
+        development: {
+            name: 'development',
+            db: {
+                adapter: 'sqlite',
+                filename: process.env.TANGO_SQLITE_FILENAME || './.data/${context.projectName}.sqlite',
+                maxConnections: 1,
+            },
+            migrations: { dir: './migrations', online: false },
+        },
+        test: {
+            name: 'test',
+            db: {
+                adapter: 'sqlite',
+                filename: process.env.TANGO_SQLITE_FILENAME || ':memory:',
+                maxConnections: 1,
+            },
+            migrations: { dir: './migrations', online: false },
+        },
+        production: {
+            name: 'production',
+            db: {
+                adapter: 'sqlite',
+                filename: process.env.TANGO_SQLITE_FILENAME || './.data/${context.projectName}.sqlite',
+                maxConnections: 1,
+            },
+            migrations: { dir: './migrations', online: false },
+        },
+    },
+});
+`;
+		return `import { defineConfig } from '@danceroutine/tango-config';
+
+export default defineConfig({
+    current: (process.env.NODE_ENV || 'development') as 'development' | 'test' | 'production',
+    environments: {
+        development: {
+            name: 'development',
+            db: {
+                adapter: 'postgres',
+                url: process.env.TANGO_DATABASE_URL || 'postgres://postgres:postgres@localhost:5432/${context.projectName}',
+                maxConnections: 10,
+            },
+            migrations: { dir: './migrations', online: true },
+        },
+        test: {
+            name: 'test',
+            db: {
+                adapter: 'postgres',
+                url: process.env.TANGO_DATABASE_URL || 'postgres://postgres:postgres@localhost:5432/${context.projectName}_test',
+                maxConnections: 5,
+            },
+            migrations: { dir: './migrations', online: true },
+        },
+        production: {
+            name: 'production',
+            db: {
+                adapter: 'postgres',
+                url: process.env.TANGO_DATABASE_URL || 'postgres://postgres:postgres@localhost:5432/${context.projectName}',
+                maxConnections: 20,
+            },
+            migrations: { dir: './migrations', online: true },
+        },
+    },
+});
+`;
+	}
+};
+
+//#endregion
+//#region src/frameworks/strategies/next/templates/models.ts
+var TodoModelTemplateBuilder = class TodoModelTemplateBuilder extends TemplateBuilder {
+	constructor() {
+		super({ name: "src/lib/models/TodoModel.ts" });
+	}
+	static context(context) {
+		return new TodoModelTemplateBuilder().setContext(context);
+	}
+	resolveTemplate(_context) {
+		return `import { z } from 'zod';
+import '@danceroutine/tango-orm/runtime';
+import { Model, t } from '@danceroutine/tango-schema';
+
+export const TodoReadSchema = z.object({
+    id: z.number(),
+    title: z.string().min(1),
+    completed: z.coerce.boolean(),
+    createdAt: z.string(),
+    updatedAt: z.string(),
+});
+
+export const TodoCreateSchema = z.object({
+    title: z.string().min(1),
+    completed: z.boolean().optional().default(false),
+});
+
+export const TodoUpdateSchema = TodoCreateSchema.partial();
+
+export type Todo = z.output<typeof TodoReadSchema>;
+
+export const TodoModel = Model({
+    namespace: 'app',
+    name: 'Todo',
+    schema: TodoReadSchema.extend({
+        id: t.primaryKey(z.number().int()),
+        title: z.string().min(1),
+        completed: t.default(z.coerce.boolean(), 'false'),
+        createdAt: t.default(z.string(), { now: true }),
+        updatedAt: t.default(z.string(), { now: true }),
+    }),
+});
+`;
+	}
+};
+var ModelsBarrelTemplateBuilder = class extends TemplateBuilder {
+	constructor() {
+		super({ name: "src/lib/models/index.ts" });
+	}
+	resolveTemplate(_context) {
+		return `export { TodoReadSchema, TodoCreateSchema, TodoUpdateSchema, TodoModel, type Todo } from './TodoModel';
+`;
+	}
+};
+
+//#endregion
+//#region src/frameworks/strategies/next/templates/serializers.ts
+var TodoSerializerTemplateBuilder = class extends TemplateBuilder {
+	constructor() {
+		super({ name: "src/serializers/TodoSerializer.ts" });
+	}
+	resolveTemplate(_context) {
+		return `import { ModelSerializer } from '@danceroutine/tango-resources';
+import { TodoCreateSchema, TodoModel, TodoReadSchema, TodoUpdateSchema, type Todo } from '@/lib/models';
+
+export class TodoSerializer extends ModelSerializer<
+    Todo,
+    typeof TodoCreateSchema,
+    typeof TodoUpdateSchema,
+    typeof TodoReadSchema
+> {
+    static readonly model = TodoModel;
+    static readonly createSchema = TodoCreateSchema;
+    static readonly updateSchema = TodoUpdateSchema;
+    static readonly outputSchema = TodoReadSchema;
+}
+`;
+	}
+};
+var SerializersBarrelTemplateBuilder = class extends TemplateBuilder {
+	constructor() {
+		super({ name: "src/serializers/index.ts" });
+	}
+	resolveTemplate(_context) {
+		return `export { TodoSerializer } from './TodoSerializer';
+`;
+	}
+};
+
+//#endregion
+//#region src/frameworks/strategies/next/templates/openapi.ts
+var OpenAPITemplateBuilder = class extends TemplateBuilder {
+	constructor() {
+		super({ name: "src/lib/openapi.ts" });
+	}
+	resolveTemplate(_context) {
+		return `import { describeViewSet, generateOpenAPISpec, type OpenAPISpec } from '@danceroutine/tango-openapi';
+import { TodoViewSet } from '@/viewsets/TodoViewSet';
+
+export function createOpenAPISpec(): OpenAPISpec {
+    return generateOpenAPISpec({
+        title: 'Tango Next.js Todo API',
+        version: '1.0.0',
+        description: 'OpenAPI document generated from Tango resource instances.',
+        resources: [describeViewSet({ basePath: '/api/todos', resource: new TodoViewSet() })],
+    });
+}
+`;
+	}
+};
+
+//#endregion
+//#region src/frameworks/strategies/next/templates/viewSet.ts
+var ViewSetTemplateBuilder = class extends TemplateBuilder {
+	constructor() {
+		super({ name: "src/viewsets/TodoViewSet.ts" });
+	}
+	resolveTemplate(_context) {
+		return `import { FilterSet, ModelViewSet } from '@danceroutine/tango-resources';
+import { type Todo } from '@/lib/models';
+import { TodoSerializer } from '@/serializers';
+
+export class TodoViewSet extends ModelViewSet<Todo, typeof TodoSerializer> {
+    constructor() {
+        super({
+            serializer: TodoSerializer,
+            filters: FilterSet.define<Todo>({
+                fields: {
+                    completed: true,
+                },
+                aliases: {
+                    q: { fields: ['title'], lookup: 'icontains' },
+                },
+            }),
+            orderingFields: ['id', 'createdAt', 'updatedAt', 'title'],
+            searchFields: ['title'],
+        });
+    }
+}
+`;
+	}
+};
+
+//#endregion
+//#region src/frameworks/strategies/next/templates/page.ts
+var PageTemplateBuilder = class extends TemplateBuilder {
+	constructor() {
+		super({ name: "src/app/page.tsx" });
+	}
+	resolveTemplate(_context) {
+		return `import { TodoModel, TodoReadSchema } from '@/lib/models';
+
+export default async function HomePage() {
+    const todos = await TodoModel.objects.query().orderBy('-createdAt').limit(10).fetch(TodoReadSchema);
+
+    return (
+        <main style={{ fontFamily: 'system-ui', margin: '2rem auto', maxWidth: '60ch' }}>
+            <h1>Tango + Next.js</h1>
+            <p>Showing {todos.results.length} todos through Tango's runtime-backed model manager.</p>
+            <ul>
+                {todos.results.map((todo) => (
+                    <li key={todo.id}>{todo.title}</li>
+                ))}
+            </ul>
+        </main>
+    );
+}
+`;
+	}
+};
+
+//#endregion
+//#region src/frameworks/strategies/next/templates/layout.ts
+var LayoutTemplateBuilder = class extends TemplateBuilder {
+	constructor() {
+		super({ name: "src/app/layout.tsx" });
+	}
+	resolveTemplate(_context) {
+		return `import type { Metadata } from 'next';
+
+export const metadata: Metadata = {
+    title: 'Tango Todo App',
+    description: 'Generated by tango new --framework next',
+};
+
+export default function RootLayout({
+    children,
+}: Readonly<{
+    children: React.ReactNode;
+}>) {
+    return (
+        <html lang="en">
+            <body>{children}</body>
+        </html>
+    );
+}
+`;
+	}
+};
+
+//#endregion
+//#region src/frameworks/strategies/next/templates/healthRoute.ts
+var HealthRouteTemplateBuilder = class extends TemplateBuilder {
+	constructor() {
+		super({ name: "src/app/api/health/route.ts" });
+	}
+	resolveTemplate(_context) {
+		return `export async function GET(): Promise<Response> {
+    return Response.json({ ok: true });
+}
+`;
+	}
+};
+
+//#endregion
+//#region src/frameworks/strategies/next/templates/todoRoute.ts
+var TodoRouteTemplateBuilder = class extends TemplateBuilder {
+	constructor() {
+		super({ name: "src/app/api/todos/[[...tango]]/route.ts" });
+	}
+	resolveTemplate(_context) {
+		return `import { NextAdapter } from '@danceroutine/tango-adapters-next/adapter';
+import { TodoViewSet } from '@/viewsets/TodoViewSet';
+
+const adapter = new NextAdapter();
+export const { GET, POST, PUT, PATCH, DELETE } = adapter.adaptViewSet(new TodoViewSet());
+`;
+	}
+};
+
+//#endregion
+//#region src/frameworks/strategies/next/templates/openapiRoute.ts
+var OpenAPIRouteTemplateBuilder = class extends TemplateBuilder {
+	constructor() {
+		super({ name: "src/app/api/openapi/route.ts" });
+	}
+	resolveTemplate(_context) {
+		return `import { createOpenAPISpec } from '@/lib/openapi';
+
+export async function GET(): Promise<Response> {
+    return Response.json(createOpenAPISpec());
+}
+`;
+	}
+};
+
+//#endregion
+//#region src/frameworks/strategies/next/templates/bootstrap.ts
+var BootstrapTemplateBuilder = class extends TemplateBuilder {
+	constructor() {
+		super({ name: "scripts/bootstrap.ts" });
+	}
+	resolveTemplate(_context) {
+		return `import { TodoModel, type Todo } from '../src/lib/models';
+
+async function seedExampleData(count = 100): Promise<void> {
+    const existing = await TodoModel.objects.query().count();
+    if (existing >= count) {
+        console.log(\`[bootstrap] Skipped; already have \${existing} todos.\`);
+        return;
+    }
+
+    const rows: Array<Partial<Todo>> = [];
+    for (let index = existing; index < count; index += 1) {
+        const now = new Date(Date.now() - index * 60_000).toISOString();
+        rows.push({
+            title: \`Seeded todo #\${index + 1}\`,
+            completed: index % 3 === 0,
+            createdAt: now,
+            updatedAt: now,
+        });
+    }
+
+    await TodoModel.objects.bulkCreate(rows);
+    console.log(\`[bootstrap] Seeded \${rows.length} todos.\`);
+}
+
+const count = Number(process.env.SEED_TODOS_COUNT || '100');
+// oxlint-disable-next-line unicorn/prefer-top-level-await
+seedExampleData(Number.isFinite(count) ? count : 100).catch((error: unknown) => {
+    console.error('[bootstrap] Failed:', error);
+    process.exit(1);
+});
+`;
+	}
+};
+
+//#endregion
+//#region src/frameworks/strategies/next/templates/readme.ts
+var ReadmeTemplateBuilder = class extends TemplateBuilder {
+	constructor() {
+		super({ name: "README.md" });
+	}
+	resolveTemplate(context) {
+		return `# ${context.projectName}
+
+This project was scaffolded by \`tango new --framework next\`.
+
+Next.js still owns pages and route handlers; Tango owns model metadata, \`Model.objects\`, serializers, migrations, querying, and resource behavior.
+
+## First-time setup
+
+Generate your first migration from the scaffolded models, then start the app:
+
+\`\`\`bash
+${context.packageManager} run make:migrations --name initial
+${context.packageManager} run dev
+\`\`\`
+
+## Scripts
+
+- \`${context.packageManager} run dev\`
+- \`${context.packageManager} run make:migrations --name add_field\`
+- \`${context.packageManager} run setup:schema\`
+- \`${context.packageManager} run bootstrap\`
+- \`${context.packageManager} run typecheck\`
+
+## Useful endpoints
+
+- \`GET /api/health\`
+- \`GET /api/openapi\`
+- \`GET|POST|PATCH|DELETE /api/todos...\`
+
+## Project layout
+
+- \`tango.config.ts\` Tango configuration
+- \`src/lib/models/\` schemas and Tango model metadata; importing the model module enables \`Model.objects\`
+- \`src/serializers/\` serializer-backed API contracts for Tango resources
+- \`src/viewsets/\` CRUD resources backed by \`Model.objects\`
+- \`src/app/page.tsx\` server-rendered page reading through \`TodoModel.objects\`
+- \`src/app/api/todos/[[...tango]]/route.ts\` Next adapter wiring for the viewset
+- \`src/lib/openapi.ts\` OpenAPI document generation
+- \`scripts/bootstrap.ts\` seed utility for a larger demo dataset
+- \`migrations/\` checked-in Tango migrations
+`;
+	}
+};
+
+//#endregion
+//#region src/frameworks/strategies/next/NextScaffoldStrategy.ts
+var NextScaffoldStrategy = class extends FrameworkScaffoldStrategy {
+	id = "next";
+	name = "Next.js";
+	description = "Bootstrap a Tango application hosted by Next.js App Router.";
+	/**
+	* Return the file templates needed for the generated Next.js project.
+	*/
+	getTemplates() {
+		return [
+			this.addFrameworkTemplate(new PackageJsonTemplateBuilder()),
+			this.addTangoTemplate(new TangoConfigTemplateBuilder()),
+			this.addFrameworkTemplate(new TsConfigTemplateBuilder()),
+			this.addFrameworkTemplate(TemplateBuilder.createStaticTemplate("next-env.d.ts", "/// <reference types=\"next\" />\n/// <reference types=\"next/image-types/global\" />\n")),
+			this.addFrameworkTemplate(TemplateBuilder.createStaticTemplate("next.config.mjs", "export default {};\n")),
+			this.addTangoTemplate(new TodoModelTemplateBuilder()),
+			this.addTangoTemplate(new ModelsBarrelTemplateBuilder()),
+			this.addTangoTemplate(new TodoSerializerTemplateBuilder()),
+			this.addTangoTemplate(new SerializersBarrelTemplateBuilder()),
+			this.addTangoTemplate(new OpenAPITemplateBuilder()),
+			this.addTangoTemplate(new ViewSetTemplateBuilder()),
+			this.addFrameworkTemplate(new LayoutTemplateBuilder()),
+			this.addFrameworkTemplate(new PageTemplateBuilder()),
+			this.addTangoTemplate(new HealthRouteTemplateBuilder()),
+			this.addTangoTemplate(new OpenAPIRouteTemplateBuilder()),
+			this.addTangoTemplate(new TodoRouteTemplateBuilder()),
+			this.addTangoTemplate(new BootstrapTemplateBuilder()),
+			this.addFrameworkTemplate(TemplateBuilder.createStaticTemplate("migrations/.gitkeep", "")),
+			this.addFrameworkTemplate(new ReadmeTemplateBuilder()),
+			this.addFrameworkTemplate(TemplateBuilder.createStaticTemplate(".gitignore", "node_modules\n.next\n.data\n.env\n"))
+		];
+	}
+};
+
+//#endregion
+//#region src/frameworks/registry/FrameworkScaffoldRegistry.ts
+var FrameworkScaffoldRegistry = class FrameworkScaffoldRegistry {
+	strategies = new Map();
+	/**
+	* Create a registry preloaded with Tango's built-in framework scaffolds.
+	*/
+	static createDefault() {
+		const registry = new FrameworkScaffoldRegistry();
+		registry.register(new ExpressScaffoldStrategy());
+		registry.register(new NextScaffoldStrategy());
+		return registry;
+	}
+	/**
+	* Register a strategy under its declared framework id.
+	*/
+	register(strategy) {
+		const existing = this.strategies.get(strategy.id);
+		if (existing) throw new Error(`Framework scaffold strategy '${strategy.id}' is already registered.`);
+		this.strategies.set(strategy.id, strategy);
+	}
+	/**
+	* Resolve a strategy for a known framework id.
+	*/
+	get(id) {
+		return this.strategies.get(id);
+	}
+	/**
+	* List all registered framework strategies in registration order.
+	*/
+	list() {
+		return [...this.strategies.values()];
+	}
+};
+
+//#endregion
+//#region src/frameworks/scaffold/scaffoldProject.ts
+function resolveTargetDir(targetDir) {
+	if (isAbsolute(targetDir)) return targetDir;
+	return resolve(process.cwd(), targetDir);
+}
+async function ensureWritableTargetDir(targetDir, options) {
+	const absoluteTargetDir = resolveTargetDir(targetDir);
+	try {
+		const targetStats = await stat(absoluteTargetDir);
+		if (!targetStats.isDirectory()) throw new Error(`Target path '${absoluteTargetDir}' exists and is not a directory.`);
+		if (options.mode === "new") {
+			const contents = await readdir(absoluteTargetDir);
+			if (contents.length > 0 && !options.force) throw new Error(`Target directory '${absoluteTargetDir}' is not empty. Pass --force to allow scaffolding into a non-empty directory.`);
+		}
+	} catch (error) {
+		if (error.code === "ENOENT") {
+			await mkdir(absoluteTargetDir, { recursive: true });
+			return;
+		}
+		throw error;
+	}
+}
+async function scaffoldProject(context, strategy, options = {}) {
+	const mode = options.mode ?? "new";
+	const skipExisting = options.skipExisting ?? mode === "init";
+	const resolvedOptions = {
+		...options,
+		mode,
+		skipExisting
+	};
+	await ensureWritableTargetDir(context.targetDir, resolvedOptions);
+	const allTemplates = strategy.getTemplates();
+	const templates = allTemplates.filter((t) => t.shouldEmit(mode));
+	for (const template of templates) {
+		const absolutePath = resolveTargetDir(resolve(context.targetDir, template.path));
+		if (skipExisting && !options.force) try {
+			await stat(absolutePath);
+			continue;
+		} catch {}
+		await mkdir(dirname(absolutePath), { recursive: true });
+		await writeFile(absolutePath, template.render(context), "utf8");
+	}
+}
+
+//#endregion
+//#region src/frameworks/index.ts
+var frameworks_exports = {};
+__export(frameworks_exports, {
+	ExpressScaffoldStrategy: () => ExpressScaffoldStrategy,
+	FrameworkScaffoldRegistry: () => FrameworkScaffoldRegistry,
+	FrameworkScaffoldStrategy: () => FrameworkScaffoldStrategy,
+	NextScaffoldStrategy: () => NextScaffoldStrategy,
+	SCAFFOLD_TEMPLATE_CATEGORY: () => SCAFFOLD_TEMPLATE_CATEGORY,
+	ScaffoldTemplateDescriptor: () => ScaffoldTemplateDescriptor,
+	scaffoldProject: () => scaffoldProject
+});
+
+//#endregion
+export { ExpressScaffoldStrategy, FrameworkScaffoldRegistry, FrameworkScaffoldStrategy, NextScaffoldStrategy, PACKAGE_MANAGER, SCAFFOLD_DATABASE_DIALECT, SCAFFOLD_TEMPLATE_CATEGORY, SUPPORTED_FRAMEWORK, ScaffoldTemplateDescriptor, frameworks_exports, scaffoldProject };
+//# sourceMappingURL=frameworks-Bp_9BOt2.js.map