@zmdb/cli 1.0.0-beta.1

package/dist/templates/command.js

@@ -0,0 +1,65 @@
+export const commandTemplate = ({ name }) => ({
+    files: [
+        {
+            path: `src/${name.fileStem}.command.ts`,
+            source: `import { assert } from 'zmdb';
+import { Command } from '@zmdb/app/commands';
+
+export interface ${name.pascal}Args {
+  readonly dryRun?: boolean;
+}
+
+export let ${name.camel}Runs = 0;
+
+@Command<${name.pascal}Args>({
+  name: '${name.fileStem}',
+  description: 'Run the ${name.fileStem} command',
+  args: {
+    type: 'object',
+    properties: {
+      dryRun: { type: 'boolean' },
+    },
+    required: [],
+  },
+  validate: raw => assert<${name.pascal}Args>(raw),
+})
+export class ${name.pascal}Command {
+  run(_args: ${name.pascal}Args): number {
+    ${name.camel}Runs += 1;
+    return 0;
+  }
+}
+`,
+        },
+        {
+            path: `src/${name.fileStem}.command.spec.ts`,
+            source: `import { createCommandApp } from '@zmdb/app/commands';
+import { createTestApp } from 'zmdb/testing';
+import { Module } from 'zmdb';
+import { describe, expect, it } from 'vitest';
+
+import {
+  ${name.pascal}Command,
+  ${name.camel}Runs,
+} from './${name.fileStem}.command.js';
+
+@Module({ commands: [${name.pascal}Command] })
+class ${name.pascal}CommandTestModule {}
+
+describe('${name.pascal}Command', () => {
+  it('runs through the command application', async () => {
+    await using testApp = createTestApp(${name.pascal}CommandTestModule);
+    await testApp.init();
+
+    await using commandApp = createCommandApp(${name.pascal}CommandTestModule);
+    await commandApp.init();
+    expect(await commandApp.run(['${name.fileStem}', '--dry-run'])).toBe(0);
+    expect(${name.camel}Runs).toBe(1);
+  });
+});
+`,
+        },
+    ],
+    instructions: [`add to src/app.module.ts, in @Module({ commands: [ … ] }):\n  ${name.pascal}Command,`],
+});
+//# sourceMappingURL=command.js.map

package/dist/templates/command.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"command.js","sourceRoot":"","sources":["../../src/templates/command.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,eAAe,GAAoB,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC,CAAC;IAC7D,KAAK,EAAE;QACL;YACE,IAAI,EAAE,OAAO,IAAI,CAAC,QAAQ,aAAa;YACvC,MAAM,EAAE;;;mBAGK,IAAI,CAAC,MAAM;;;;aAIjB,IAAI,CAAC,KAAK;;WAEZ,IAAI,CAAC,MAAM;WACX,IAAI,CAAC,QAAQ;0BACE,IAAI,CAAC,QAAQ;;;;;;;;4BAQX,IAAI,CAAC,MAAM;;eAExB,IAAI,CAAC,MAAM;eACX,IAAI,CAAC,MAAM;MACpB,IAAI,CAAC,KAAK;;;;CAIf;SACI;QACD;YACE,IAAI,EAAE,OAAO,IAAI,CAAC,QAAQ,kBAAkB;YAC5C,MAAM,EAAE;;;;;;IAMV,IAAI,CAAC,MAAM;IACX,IAAI,CAAC,KAAK;YACF,IAAI,CAAC,QAAQ;;uBAEF,IAAI,CAAC,MAAM;QAC1B,IAAI,CAAC,MAAM;;YAEP,IAAI,CAAC,MAAM;;0CAEmB,IAAI,CAAC,MAAM;;;gDAGL,IAAI,CAAC,MAAM;;oCAEvB,IAAI,CAAC,QAAQ;aACpC,IAAI,CAAC,KAAK;;;CAGtB;SACI;KACF;IACD,YAAY,EAAE,CAAC,iEAAiE,IAAI,CAAC,MAAM,UAAU,CAAC;CACvG,CAAC,CAAC"}

package/dist/templates/controller.d.ts

@@ -0,0 +1,3 @@
+import type { TemplateFactory } from './types.js';
+export declare const controllerTemplate: TemplateFactory;
+//# sourceMappingURL=controller.d.ts.map

package/dist/templates/controller.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"controller.d.ts","sourceRoot":"","sources":["../../src/templates/controller.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAElD,eAAO,MAAM,kBAAkB,EAAE,eAuC/B,CAAC"}

package/dist/templates/controller.js

@@ -0,0 +1,41 @@
+export const controllerTemplate = ({ name }) => ({
+    files: [
+        {
+            path: `src/${name.fileStem}.controller.ts`,
+            source: `import { Controller, Get } from 'zmdb';
+
+@Controller('/${name.fileStem}')
+export class ${name.pascal}Controller {
+  @Get()
+  list(): { readonly resource: string; readonly items: readonly unknown[] } {
+    return { resource: '${name.fileStem}', items: [] };
+  }
+}
+`,
+        },
+        {
+            path: `src/${name.fileStem}.controller.spec.ts`,
+            source: `import { Module } from 'zmdb';
+import { createTestApp } from 'zmdb/testing';
+import { bodyText } from 'zmdb/web';
+import { describe, expect, it } from 'vitest';
+
+import { ${name.pascal}Controller } from './${name.fileStem}.controller.js';
+
+@Module({ controllers: [${name.pascal}Controller] })
+class ${name.pascal}ControllerTestModule {}
+
+describe('${name.pascal}Controller', () => {
+  it('serves its collection route', async () => {
+    await using app = createTestApp(${name.pascal}ControllerTestModule);
+    const response = await app.request({ method: 'GET', path: '/${name.fileStem}', headers: {} });
+    expect(response.status).toBe(200);
+    expect(JSON.parse(await bodyText(response))).toEqual({ resource: '${name.fileStem}', items: [] });
+  });
+});
+`,
+        },
+    ],
+    instructions: [`add to src/app.module.ts, in @Module({ controllers: [ … ] }):\n  ${name.pascal}Controller,`],
+});
+//# sourceMappingURL=controller.js.map

package/dist/templates/controller.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"controller.js","sourceRoot":"","sources":["../../src/templates/controller.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,kBAAkB,GAAoB,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC,CAAC;IAChE,KAAK,EAAE;QACL;YACE,IAAI,EAAE,OAAO,IAAI,CAAC,QAAQ,gBAAgB;YAC1C,MAAM,EAAE;;gBAEE,IAAI,CAAC,QAAQ;eACd,IAAI,CAAC,MAAM;;;0BAGA,IAAI,CAAC,QAAQ;;;CAGtC;SACI;QACD;YACE,IAAI,EAAE,OAAO,IAAI,CAAC,QAAQ,qBAAqB;YAC/C,MAAM,EAAE;;;;;WAKH,IAAI,CAAC,MAAM,wBAAwB,IAAI,CAAC,QAAQ;;0BAEjC,IAAI,CAAC,MAAM;QAC7B,IAAI,CAAC,MAAM;;YAEP,IAAI,CAAC,MAAM;;sCAEe,IAAI,CAAC,MAAM;kEACiB,IAAI,CAAC,QAAQ;;wEAEP,IAAI,CAAC,QAAQ;;;CAGpF;SACI;KACF;IACD,YAAY,EAAE,CAAC,oEAAoE,IAAI,CAAC,MAAM,aAAa,CAAC;CAC7G,CAAC,CAAC"}

package/dist/templates/index.d.ts

@@ -0,0 +1,4 @@
+import type { ScaffoldKind, TemplateFactory } from './types.js';
+export declare function templateFor(kind: ScaffoldKind): TemplateFactory;
+export type { ScaffoldKind, ScaffoldName, TemplateContext, TemplateFactory, TemplateFile, TemplatePlan, } from './types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/templates/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/templates/index.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,YAAY,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAWhE,wBAAgB,WAAW,CAAC,IAAI,EAAE,YAAY,GAAG,eAAe,CAE/D;AAED,YAAY,EACV,YAAY,EACZ,YAAY,EACZ,eAAe,EACf,eAAe,EACf,YAAY,EACZ,YAAY,GACb,MAAM,YAAY,CAAC"}

package/dist/templates/index.js

@@ -0,0 +1,18 @@
+import { commandTemplate } from './command.js';
+import { controllerTemplate } from './controller.js';
+import { moduleTemplate } from './module.js';
+import { projectTemplate } from './project.js';
+import { repositoryTemplate } from './repository.js';
+import { schemaTemplate } from './schema.js';
+const TEMPLATES = {
+    command: commandTemplate,
+    controller: controllerTemplate,
+    module: moduleTemplate,
+    project: projectTemplate,
+    repository: repositoryTemplate,
+    schema: schemaTemplate,
+};
+export function templateFor(kind) {
+    return TEMPLATES[kind];
+}
+//# sourceMappingURL=index.js.map

package/dist/templates/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/templates/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAC/C,OAAO,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AACrD,OAAO,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAC7C,OAAO,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAC/C,OAAO,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AACrD,OAAO,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAG7C,MAAM,SAAS,GAAoD;IACjE,OAAO,EAAE,eAAe;IACxB,UAAU,EAAE,kBAAkB;IAC9B,MAAM,EAAE,cAAc;IACtB,OAAO,EAAE,eAAe;IACxB,UAAU,EAAE,kBAAkB;IAC9B,MAAM,EAAE,cAAc;CACvB,CAAC;AAEF,MAAM,UAAU,WAAW,CAAC,IAAkB;IAC5C,OAAO,SAAS,CAAC,IAAI,CAAC,CAAC;AACzB,CAAC"}

package/dist/templates/module.d.ts

@@ -0,0 +1,3 @@
+import type { TemplateFactory } from './types.js';
+export declare const moduleTemplate: TemplateFactory;
+//# sourceMappingURL=module.d.ts.map

package/dist/templates/module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"module.d.ts","sourceRoot":"","sources":["../../src/templates/module.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAElD,eAAO,MAAM,cAAc,EAAE,eAuC3B,CAAC"}

package/dist/templates/module.js

@@ -0,0 +1,41 @@
+export const moduleTemplate = ({ name }) => ({
+    files: [
+        {
+            path: `src/${name.fileStem}.module.ts`,
+            source: `import { Module } from 'zmdb';
+import { createToken } from 'zmdb/web';
+
+export interface ${name.pascal}Status {
+  readonly name: '${name.fileStem}';
+  readonly ready: true;
+}
+
+export const ${name.constant}_STATUS = createToken<${name.pascal}Status>('${name.pascal}Status');
+
+@Module({
+  providers: [{ token: ${name.constant}_STATUS, useValue: { name: '${name.fileStem}', ready: true } }],
+  exports: [${name.constant}_STATUS],
+})
+export class ${name.pascal}Module {}
+`,
+        },
+        {
+            path: `src/${name.fileStem}.module.spec.ts`,
+            source: `import { createTestApp } from 'zmdb/testing';
+import { describe, expect, it } from 'vitest';
+
+import { ${name.constant}_STATUS, ${name.pascal}Module } from './${name.fileStem}.module.js';
+
+describe('${name.pascal}Module', () => {
+  it('registers its status provider', async () => {
+    await using app = createTestApp(${name.pascal}Module);
+    const status = app.get(${name.constant}_STATUS);
+    expect(status).toEqual({ name: '${name.fileStem}', ready: true });
+  });
+});
+`,
+        },
+    ],
+    instructions: [`add to src/app.module.ts, in @Module({ imports: [ … ] }):\n  ${name.pascal}Module,`],
+});
+//# sourceMappingURL=module.js.map

package/dist/templates/module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"module.js","sourceRoot":"","sources":["../../src/templates/module.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,cAAc,GAAoB,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC,CAAC;IAC5D,KAAK,EAAE;QACL;YACE,IAAI,EAAE,OAAO,IAAI,CAAC,QAAQ,YAAY;YACtC,MAAM,EAAE;;;mBAGK,IAAI,CAAC,MAAM;oBACV,IAAI,CAAC,QAAQ;;;;eAIlB,IAAI,CAAC,QAAQ,yBAAyB,IAAI,CAAC,MAAM,YAAY,IAAI,CAAC,MAAM;;;yBAG9D,IAAI,CAAC,QAAQ,+BAA+B,IAAI,CAAC,QAAQ;cACpE,IAAI,CAAC,QAAQ;;eAEZ,IAAI,CAAC,MAAM;CACzB;SACI;QACD;YACE,IAAI,EAAE,OAAO,IAAI,CAAC,QAAQ,iBAAiB;YAC3C,MAAM,EAAE;;;WAGH,IAAI,CAAC,QAAQ,YAAY,IAAI,CAAC,MAAM,oBAAoB,IAAI,CAAC,QAAQ;;YAEpE,IAAI,CAAC,MAAM;;sCAEe,IAAI,CAAC,MAAM;6BACpB,IAAI,CAAC,QAAQ;sCACJ,IAAI,CAAC,QAAQ;;;CAGlD;SACI;KACF;IACD,YAAY,EAAE,CAAC,gEAAgE,IAAI,CAAC,MAAM,SAAS,CAAC;CACrG,CAAC,CAAC"}

package/dist/templates/project.d.ts

@@ -0,0 +1,3 @@
+import { type TemplateFactory } from './types.js';
+export declare const projectTemplate: TemplateFactory;
+//# sourceMappingURL=project.d.ts.map

package/dist/templates/project.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"project.d.ts","sourceRoot":"","sources":["../../src/templates/project.ts"],"names":[],"mappings":"AAAA,OAAO,EAAkB,KAAK,eAAe,EAAE,MAAM,YAAY,CAAC;AAElE,eAAO,MAAM,eAAe,EAAE,eAsR5B,CAAC"}

package/dist/templates/project.js

@@ -0,0 +1,280 @@
+import { FORMAT_OPTIONS } from './types.js';
+export const projectTemplate = ({ name, packageVersion }) => ({
+    files: [
+        {
+            path: 'package.json',
+            source: `${JSON.stringify({
+                name: name.fileStem,
+                private: true,
+                version: '0.1.0',
+                type: 'module',
+                scripts: {
+                    build: 'node scripts/build.mjs app',
+                    check: 'node scripts/build.mjs fmt-check && tsc --noEmit && oxlint . && node scripts/build.mjs test && vitest run --config vitest.config.ts',
+                    fmt: 'node scripts/build.mjs fmt',
+                    'fmt:check': 'node scripts/build.mjs fmt-check',
+                    lint: 'oxlint .',
+                    start: 'node dist/main.mjs',
+                    test: 'node scripts/build.mjs test && vitest run --config vitest.config.ts',
+                    typecheck: 'tsc --noEmit',
+                },
+                dependencies: {
+                    '@zmdb/sqlite': packageVersion,
+                    zmdb: packageVersion,
+                },
+                devDependencies: {
+                    '@types/node': '26.4.1',
+                    esbuild: '0.28.2',
+                    oxfmt: '0.66.0',
+                    oxlint: '1.81.0',
+                    typescript: '7.0.2',
+                    vitest: '5.0.0',
+                },
+                engines: {
+                    node: '>=26',
+                },
+            })}\n`,
+        },
+        {
+            path: 'tsconfig.json',
+            source: `${JSON.stringify({
+                compilerOptions: {
+                    allowImportingTsExtensions: false,
+                    exactOptionalPropertyTypes: true,
+                    isolatedModules: true,
+                    lib: ['ESNext', 'DOM', 'DOM.Iterable'],
+                    module: 'NodeNext',
+                    moduleResolution: 'NodeNext',
+                    noEmit: true,
+                    noImplicitOverride: true,
+                    noUncheckedIndexedAccess: true,
+                    skipLibCheck: true,
+                    strict: true,
+                    target: 'ESNext',
+                    types: ['node'],
+                    verbatimModuleSyntax: true,
+                },
+                include: ['src/**/*.ts', 'vitest.config.ts', 'zmdb.config.ts'],
+            })}\n`,
+        },
+        {
+            path: 'scripts/build.mjs',
+            source: `import { glob, readFile, rm, writeFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import { build } from 'esbuild';
+import { format } from 'oxfmt';
+import { zmdbAot } from 'zmdb/compiler';
+
+const root = dirname(dirname(fileURLToPath(import.meta.url)));
+const formatOptions = ${JSON.stringify(FORMAT_OPTIONS)};
+
+async function formatProject(check) {
+  const paths = glob(['**/*.ts', '**/*.mjs', '**/*.json'], {
+    cwd: root,
+    exclude: ['**/node_modules/**', '**/dist/**', '**/generated-tests/**', '**/.cache/**', '**/package-lock.json', '**/npm-shrinkwrap.json'],
+  });
+  for await (const path of paths) {
+    const absolute = join(root, path);
+    const source = await readFile(absolute, 'utf8');
+    const result = await format(path, source, formatOptions);
+    if (result.errors.length > 0) throw new Error(JSON.stringify(result.errors));
+    if (result.code === source) continue;
+    if (check) {
+      process.stderr.write(path + '\\n');
+      process.exitCode = 1;
+    } else {
+      await writeFile(absolute, result.code);
+    }
+  }
+}
+
+async function aotPlugin() {
+  const plugin = await zmdbAot({ cwd: root });
+  return {
+    name: plugin.name,
+    setup(esbuild) {
+      esbuild.onLoad({ filter: /\\.[cm]?tsx?$/ }, async ({ path }) => {
+        const code = await readFile(path, 'utf8');
+        const result = plugin.transform(code, path);
+        return { contents: result?.code ?? code, loader: path.endsWith('x') ? 'tsx' : 'ts' };
+      });
+      esbuild.onEnd(() => plugin.buildEnd?.());
+    },
+  };
+}
+
+const common = {
+  bundle: true,
+  format: 'esm',
+  packages: 'external',
+  platform: 'node',
+  target: 'es2022',
+};
+
+const mode = process.argv[2];
+if (mode === 'fmt' || mode === 'fmt-check') {
+  await formatProject(mode === 'fmt-check');
+} else if (mode === 'app') {
+  await build({
+    ...common,
+    entryPoints: [join(root, 'src', 'main.ts')],
+    outfile: join(root, 'dist', 'main.mjs'),
+    plugins: [await aotPlugin()],
+  });
+} else if (mode === 'test') {
+  const entryPoints = [];
+  for await (const path of glob('src/**/*.spec.ts', { cwd: root })) {
+    entryPoints.push(join(root, path));
+  }
+  const outdir = join(root, 'generated-tests');
+  await rm(outdir, { recursive: true, force: true });
+  await build({
+    ...common,
+    entryPoints,
+    outbase: join(root, 'src'),
+    outdir,
+    outExtension: { '.js': '.mjs' },
+    plugins: [await aotPlugin()],
+  });
+} else {
+  throw new Error('usage: node scripts/build.mjs <app|test|fmt|fmt-check>');
+}
+`,
+        },
+        {
+            path: 'vitest.config.ts',
+            source: `import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    include: ['generated-tests/**/*.spec.mjs'],
+  },
+});
+`,
+        },
+        {
+            path: 'zmdb.config.ts',
+            source: `import { DatabaseSync } from 'node:sqlite';
+import { fileURLToPath } from 'node:url';
+
+import { defineConfig } from 'zmdb';
+import { sqlite, sqliteDriver } from 'zmdb/sqlite';
+
+const databasePath = fileURLToPath(new URL('./database.sqlite', import.meta.url));
+
+export default defineConfig({
+  schema: ['src/**/*.ts'],
+  dialect: sqlite,
+  project: './tsconfig.json',
+  out: './migrations',
+  driver: () => sqliteDriver(new DatabaseSync(databasePath)),
+});
+`,
+        },
+        {
+            path: 'src/app.module.ts',
+            source: `import { Module } from 'zmdb';
+
+import { HealthController } from './health.controller.js';
+
+@Module({ controllers: [HealthController] })
+export class AppModule {}
+`,
+        },
+        {
+            path: 'src/main.ts',
+            source: `import { createServer } from 'node:http';
+
+import { compileModule, createRouter, toNodeHandler } from 'zmdb/web';
+
+import { AppModule } from './app.module.js';
+
+const port = Number(process.env.PORT ?? '3000');
+if (!Number.isInteger(port) || port < 0 || port > 65_535) {
+  throw new RangeError(\`PORT must be an integer from 0 through 65535, received \${String(process.env.PORT)}\`);
+}
+
+const compiled = compileModule(AppModule);
+const router = createRouter();
+for (const controller of compiled.controllers) {
+  router.register(controller);
+}
+
+const handle = toNodeHandler(router);
+const server = createServer((request, response) => {
+  const method = request.method;
+  if (method === undefined) {
+    response.writeHead(400).end('request method is required');
+    return;
+  }
+  handle(
+    {
+      method,
+      headers: request.headers,
+      ...(request.url === undefined ? {} : { url: request.url }),
+      on(event, listener) {
+        request.on(event, listener);
+      },
+      setEncoding() {
+        request.setEncoding('utf8');
+      },
+    },
+    response,
+  );
+});
+server.listen(port, '127.0.0.1', () => {
+  const address = server.address();
+  const selectedPort = typeof address === 'object' && address !== null ? address.port : port;
+  console.log(\`listening on http://127.0.0.1:\${String(selectedPort)}\`);
+});
+`,
+        },
+        {
+            path: 'src/health.controller.ts',
+            source: `import { Controller, Get } from 'zmdb';
+
+@Controller('/health')
+export class HealthController {
+  @Get()
+  check(): { readonly ok: true } {
+    return { ok: true };
+  }
+}
+`,
+        },
+        {
+            path: 'src/health.controller.spec.ts',
+            source: `import { createTestApp } from 'zmdb/testing';
+import { bodyText } from 'zmdb/web';
+import { describe, expect, it } from 'vitest';
+
+import config from '../zmdb.config.js';
+import { AppModule } from './app.module.js';
+
+describe('generated project', () => {
+  it('serves health and opens its sqlite database', async () => {
+    await using app = createTestApp(AppModule);
+    const response = await app.request({ method: 'GET', path: '/health', headers: {} });
+    expect(response.status).toBe(200);
+    expect(JSON.parse(await bodyText(response))).toEqual({ ok: true });
+
+    const rows = await config.driver().execute({ text: 'SELECT 1 AS ok', parameters: [] });
+    expect(Reflect.get(rows[0] ?? {}, 'ok')).toBe(1);
+  });
+});
+`,
+        },
+        {
+            path: '.gitignore',
+            source: `node_modules
+dist
+generated-tests
+coverage
+database.sqlite
+`,
+        },
+    ],
+});
+//# sourceMappingURL=project.js.map

package/dist/templates/project.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"project.js","sourceRoot":"","sources":["../../src/templates/project.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAwB,MAAM,YAAY,CAAC;AAElE,MAAM,CAAC,MAAM,eAAe,GAAoB,CAAC,EAAE,IAAI,EAAE,cAAc,EAAE,EAAE,EAAE,CAAC,CAAC;IAC7E,KAAK,EAAE;QACL;YACE,IAAI,EAAE,cAAc;YACpB,MAAM,EAAE,GAAG,IAAI,CAAC,SAAS,CAAC;gBACxB,IAAI,EAAE,IAAI,CAAC,QAAQ;gBACnB,OAAO,EAAE,IAAI;gBACb,OAAO,EAAE,OAAO;gBAChB,IAAI,EAAE,QAAQ;gBACd,OAAO,EAAE;oBACP,KAAK,EAAE,4BAA4B;oBACnC,KAAK,EACH,qIAAqI;oBACvI,GAAG,EAAE,4BAA4B;oBACjC,WAAW,EAAE,kCAAkC;oBAC/C,IAAI,EAAE,UAAU;oBAChB,KAAK,EAAE,oBAAoB;oBAC3B,IAAI,EAAE,qEAAqE;oBAC3E,SAAS,EAAE,cAAc;iBAC1B;gBACD,YAAY,EAAE;oBACZ,cAAc,EAAE,cAAc;oBAC9B,IAAI,EAAE,cAAc;iBACrB;gBACD,eAAe,EAAE;oBACf,aAAa,EAAE,QAAQ;oBACvB,OAAO,EAAE,QAAQ;oBACjB,KAAK,EAAE,QAAQ;oBACf,MAAM,EAAE,QAAQ;oBAChB,UAAU,EAAE,OAAO;oBACnB,MAAM,EAAE,OAAO;iBAChB;gBACD,OAAO,EAAE;oBACP,IAAI,EAAE,MAAM;iBACb;aACF,CAAC,IAAI;SACP;QACD;YACE,IAAI,EAAE,eAAe;YACrB,MAAM,EAAE,GAAG,IAAI,CAAC,SAAS,CAAC;gBACxB,eAAe,EAAE;oBACf,0BAA0B,EAAE,KAAK;oBACjC,0BAA0B,EAAE,IAAI;oBAChC,eAAe,EAAE,IAAI;oBACrB,GAAG,EAAE,CAAC,QAAQ,EAAE,KAAK,EAAE,cAAc,CAAC;oBACtC,MAAM,EAAE,UAAU;oBAClB,gBAAgB,EAAE,UAAU;oBAC5B,MAAM,EAAE,IAAI;oBACZ,kBAAkB,EAAE,IAAI;oBACxB,wBAAwB,EAAE,IAAI;oBAC9B,YAAY,EAAE,IAAI;oBAClB,MAAM,EAAE,IAAI;oBACZ,MAAM,EAAE,QAAQ;oBAChB,KAAK,EAAE,CAAC,MAAM,CAAC;oBACf,oBAAoB,EAAE,IAAI;iBAC3B;gBACD,OAAO,EAAE,CAAC,aAAa,EAAE,kBAAkB,EAAE,gBAAgB,CAAC;aAC/D,CAAC,IAAI;SACP;QACD;YACE,IAAI,EAAE,mBAAmB;YACzB,MAAM,EAAE;;;;;;;;;wBASU,IAAI,CAAC,SAAS,CAAC,cAAc,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyErD;SACI;QACD;YACE,IAAI,EAAE,kBAAkB;YACxB,MAAM,EAAE;;;;;;;CAOb;SACI;QACD;YACE,IAAI,EAAE,gBAAgB;YACtB,MAAM,EAAE;;;;;;;;;;;;;;;CAeb;SACI;QACD;YACE,IAAI,EAAE,mBAAmB;YACzB,MAAM,EAAE;;;;;;CAMb;SACI;QACD;YACE,IAAI,EAAE,aAAa;YACnB,MAAM,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4Cb;SACI;QACD;YACE,IAAI,EAAE,0BAA0B;YAChC,MAAM,EAAE;;;;;;;;;CASb;SACI;QACD;YACE,IAAI,EAAE,+BAA+B;YACrC,MAAM,EAAE;;;;;;;;;;;;;;;;;;CAkBb;SACI;QACD;YACE,IAAI,EAAE,YAAY;YAClB,MAAM,EAAE;;;;;CAKb;SACI;KACF;CACF,CAAC,CAAC"}

package/dist/templates/repository.d.ts

@@ -0,0 +1,3 @@
+import type { TemplateFactory } from './types.js';
+export declare const repositoryTemplate: TemplateFactory;
+//# sourceMappingURL=repository.d.ts.map

package/dist/templates/repository.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"repository.d.ts","sourceRoot":"","sources":["../../src/templates/repository.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAElD,eAAO,MAAM,kBAAkB,EAAE,eAgE/B,CAAC"}

package/dist/templates/repository.js

@@ -0,0 +1,66 @@
+export const repositoryTemplate = ({ name }) => ({
+    files: [
+        {
+            path: `src/${name.fileStem}.repository.ts`,
+            source: `import { defineRepository, schemaOf, type Driver } from 'zmdb';
+import type { BaseRepository } from 'zmdb/orm';
+import { repositoryToken } from 'zmdb/app/data';
+import type { ProviderDef } from 'zmdb/app/modules';
+
+import type { ${name.pascal} } from './${name.fileStem}.js';
+
+const ${name.camel}Schema = schemaOf<${name.pascal}>();
+
+export const ${name.constant}_REPOSITORY = repositoryToken<${name.pascal}>('${name.pascal}Repository');
+
+export function ${name.camel}RepositoryProvider(driver: Driver): ProviderDef<BaseRepository<${name.pascal}>> {
+  return {
+    token: ${name.constant}_REPOSITORY,
+    useFactory: () => defineRepository(${name.camel}Schema, driver),
+  };
+}
+`,
+        },
+        {
+            path: `src/${name.fileStem}.repository.spec.ts`,
+            source: `import { DatabaseSync } from 'node:sqlite';
+
+import { sqliteDriver } from 'zmdb/sqlite';
+import { createTestApp } from 'zmdb/testing';
+import { Module } from 'zmdb';
+import { describe, expect, it } from 'vitest';
+
+import {
+  ${name.constant}_REPOSITORY,
+  ${name.camel}RepositoryProvider,
+} from './${name.fileStem}.repository.js';
+
+describe('${name.pascal} repository provider', () => {
+  it('creates and reads a row through sqlite', async () => {
+    const database = new DatabaseSync(':memory:');
+    try {
+      database.exec(
+        'CREATE TABLE "${name.table}" ("id" INTEGER PRIMARY KEY AUTOINCREMENT, "name" TEXT NOT NULL)',
+      );
+
+      @Module({ providers: [${name.camel}RepositoryProvider(sqliteDriver(database))] })
+      class ${name.pascal}RepositoryTestModule {}
+
+      await using app = createTestApp(${name.pascal}RepositoryTestModule);
+      const repository = app.get(${name.constant}_REPOSITORY);
+      const created = await repository.create({ name: 'Ada' });
+      expect(created.name).toBe('Ada');
+      expect((await repository.findById(created.id))?.name).toBe('Ada');
+    } finally {
+      database.close();
+    }
+  });
+});
+`,
+        },
+    ],
+    instructions: [
+        `add to src/app.module.ts, in @Module({ providers: [ … ] }):\n  ${name.camel}RepositoryProvider(driver),`,
+    ],
+});
+//# sourceMappingURL=repository.js.map

package/dist/templates/repository.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"repository.js","sourceRoot":"","sources":["../../src/templates/repository.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,kBAAkB,GAAoB,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC,CAAC;IAChE,KAAK,EAAE;QACL;YACE,IAAI,EAAE,OAAO,IAAI,CAAC,QAAQ,gBAAgB;YAC1C,MAAM,EAAE;;;;;gBAKE,IAAI,CAAC,MAAM,cAAc,IAAI,CAAC,QAAQ;;QAE9C,IAAI,CAAC,KAAK,qBAAqB,IAAI,CAAC,MAAM;;eAEnC,IAAI,CAAC,QAAQ,iCAAiC,IAAI,CAAC,MAAM,MAAM,IAAI,CAAC,MAAM;;kBAEvE,IAAI,CAAC,KAAK,kEAAkE,IAAI,CAAC,MAAM;;aAE5F,IAAI,CAAC,QAAQ;yCACe,IAAI,CAAC,KAAK;;;CAGlD;SACI;QACD;YACE,IAAI,EAAE,OAAO,IAAI,CAAC,QAAQ,qBAAqB;YAC/C,MAAM,EAAE;;;;;;;;IAQV,IAAI,CAAC,QAAQ;IACb,IAAI,CAAC,KAAK;YACF,IAAI,CAAC,QAAQ;;YAEb,IAAI,CAAC,MAAM;;;;;yBAKE,IAAI,CAAC,KAAK;;;8BAGL,IAAI,CAAC,KAAK;cAC1B,IAAI,CAAC,MAAM;;wCAEe,IAAI,CAAC,MAAM;mCAChB,IAAI,CAAC,QAAQ;;;;;;;;;CAS/C;SACI;KACF;IACD,YAAY,EAAE;QACZ,kEAAkE,IAAI,CAAC,KAAK,6BAA6B;KAC1G;CACF,CAAC,CAAC"}

package/dist/templates/schema.d.ts

@@ -0,0 +1,3 @@
+import type { TemplateFactory } from './types.js';
+export declare const schemaTemplate: TemplateFactory;
+//# sourceMappingURL=schema.d.ts.map

package/dist/templates/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/templates/schema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAElD,eAAO,MAAM,cAAc,EAAE,eAkC3B,CAAC"}

package/dist/templates/schema.js

@@ -0,0 +1,36 @@
+export const schemaTemplate = ({ name }) => ({
+    files: [
+        {
+            path: `src/${name.fileStem}.ts`,
+            source: `import type { PrimaryKey, Serial, Sql, Table } from 'zmdb';
+
+export interface ${name.pascal} extends Table<'${name.table}'> {
+  id: number & Sql<'integer'> & Serial & PrimaryKey;
+  name: string & Sql<'text'>;
+}
+`,
+        },
+        {
+            path: `src/${name.fileStem}.spec.ts`,
+            source: `import { Module, is, schemaOf } from 'zmdb';
+import { createTestApp } from 'zmdb/testing';
+import { describe, expect, it } from 'vitest';
+
+import type { ${name.pascal} } from './${name.fileStem}.js';
+
+@Module({})
+class ${name.pascal}SchemaTestModule {}
+
+describe('${name.pascal} schema', () => {
+  it('emits the table declaration and validates through the transformer', async () => {
+    await using app = createTestApp(${name.pascal}SchemaTestModule);
+    await app.init();
+    expect(schemaOf<${name.pascal}>().table).toBe('${name.table}');
+    expect(is<{ id: number }>({ id: 'x' })).toBe(false);
+  });
+});
+`,
+        },
+    ],
+});
+//# sourceMappingURL=schema.js.map

package/dist/templates/schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.js","sourceRoot":"","sources":["../../src/templates/schema.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,cAAc,GAAoB,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC,CAAC;IAC5D,KAAK,EAAE;QACL;YACE,IAAI,EAAE,OAAO,IAAI,CAAC,QAAQ,KAAK;YAC/B,MAAM,EAAE;;mBAEK,IAAI,CAAC,MAAM,mBAAmB,IAAI,CAAC,KAAK;;;;CAI1D;SACI;QACD;YACE,IAAI,EAAE,OAAO,IAAI,CAAC,QAAQ,UAAU;YACpC,MAAM,EAAE;;;;gBAIE,IAAI,CAAC,MAAM,cAAc,IAAI,CAAC,QAAQ;;;QAG9C,IAAI,CAAC,MAAM;;YAEP,IAAI,CAAC,MAAM;;sCAEe,IAAI,CAAC,MAAM;;sBAE3B,IAAI,CAAC,MAAM,oBAAoB,IAAI,CAAC,KAAK;;;;CAI9D;SACI;KACF;CACF,CAAC,CAAC"}

package/dist/templates/types.d.ts

@@ -0,0 +1,25 @@
+import type { FormatConfig } from 'oxfmt';
+export declare const FORMAT_OPTIONS: FormatConfig;
+export type ScaffoldKind = 'command' | 'controller' | 'module' | 'project' | 'repository' | 'schema';
+export interface ScaffoldName {
+    readonly input: string;
+    readonly fileStem: string;
+    readonly pascal: string;
+    readonly camel: string;
+    readonly constant: string;
+    readonly table: string;
+}
+export interface TemplateContext {
+    readonly name: ScaffoldName;
+    readonly packageVersion: string;
+}
+export interface TemplateFile {
+    readonly path: string;
+    readonly source: string;
+}
+export interface TemplatePlan {
+    readonly files: readonly TemplateFile[];
+    readonly instructions?: readonly string[];
+}
+export type TemplateFactory = (context: TemplateContext) => TemplatePlan;
+//# sourceMappingURL=types.d.ts.map