@skyf0xx/hedgehog-core-full-stack-app 1.0.0

package/workspace/tools/generators/repository/generator.ts

@@ -0,0 +1,298 @@
+import { formatFiles, Tree } from '@nx/devkit';
+import { generateLibShell } from '../lib-shell';
+import { moduleNames, ModuleNames } from '../naming';
+
+interface RepositoryGeneratorOptions {
+  module: string;
+}
+
+export default async function repositoryGenerator(
+  tree: Tree,
+  options: RepositoryGeneratorOptions,
+) {
+  const names = moduleNames(options.module);
+  const root = `libs/${names.module}/repository`;
+
+  await generateLibShell(tree, {
+    directory: root,
+    importName: `${names.module}-repository`,
+    // The pair packages/config/eslint-base.js's depConstraints expect for a
+    // repository lib: it holds the port interface and its Drizzle adapter
+    // in one project, so `type:adapter` is what a service is allowed to
+    // depend on; the no-restricted-imports rule is what stops the service
+    // from reaching the adapter through it.
+    tags: [`scope:${names.module}`, 'type:adapter'],
+    dependencies: { db: 'workspace:*' },
+    references: ['../../../packages/db/tsconfig.lib.json'],
+  });
+
+  tree.write(`${root}/src/lib/${names.entityKebab}.port.ts`, portFile(names));
+  tree.write(
+    `${root}/src/lib/${names.entityKebab}.adapter.ts`,
+    adapterFile(names),
+  );
+  tree.write(
+    `${root}/src/lib/${names.entityKebab}.adapter.spec.ts`,
+    adapterSpecFile(names),
+  );
+  tree.write(`${root}/src/index.ts`, barrelFile(names));
+
+  await formatFiles(tree);
+}
+
+/**
+ * The port is the only symbol a service may see, so the DI token lives
+ * beside it rather than in the adapter file — importing the token out of
+ * `*.adapter.ts` would drag the concrete class across the boundary
+ * eslint-base.js's no-restricted-imports rule draws.
+ */
+function portFile(names: ModuleNames): string {
+  const { entityPascal, entityConstant } = names;
+
+  return `import type { ${entityPascal}, New${entityPascal} } from 'db';
+
+// Re-exported so a service can name the entity type without importing
+// packages/db itself — eslint-base.js's no-restricted-imports rule bans a
+// service from reaching the database package at all, type-only or not.
+export type { ${entityPascal} };
+
+export type ${entityPascal}Draft = Omit<
+  New${entityPascal},
+  'id' | 'createdAt' | 'updatedAt'
+>;
+export type ${entityPascal}Patch = Partial<${entityPascal}Draft>;
+
+export interface ${entityPascal}Repository {
+  findAll(): Promise<${entityPascal}[]>;
+  /** A miss is a plain absence — the service decides what it means. */
+  findById(id: string): Promise<${entityPascal} | undefined>;
+  create(draft: ${entityPascal}Draft): Promise<${entityPascal}>;
+  update(id: string, patch: ${entityPascal}Patch): Promise<${entityPascal} | undefined>;
+  remove(id: string): Promise<boolean>;
+  /**
+   * Runs \`work\` inside one database transaction, handing it a repository
+   * bound to that transaction. A throw rolls every write back, which is how
+   * a multi-write service method stays all-or-nothing without the service
+   * itself knowing about Drizzle.
+   */
+  transaction<T>(
+    work: (repository: ${entityPascal}Repository) => Promise<T>,
+  ): Promise<T>;
+}
+
+export const ${entityConstant}_REPOSITORY = Symbol('${entityPascal}Repository');
+`;
+}
+
+function adapterFile(names: ModuleNames): string {
+  const { entityPascal, camel } = names;
+
+  return `import { eq } from 'drizzle-orm';
+import type { NodePgDatabase } from 'drizzle-orm/node-postgres';
+import { ${camel}, type ${entityPascal} } from 'db';
+import type {
+  ${entityPascal}Draft,
+  ${entityPascal}Patch,
+  ${entityPascal}Repository,
+} from './${names.entityKebab}.port';
+
+/**
+ * Takes a thunk rather than a database instance so that constructing the
+ * adapter — which apps/api's module does at DI-container build time —
+ * opens no connection. getDb() reads DATABASE_URL and exits the process
+ * when it is absent, which would make merely compiling AppModule in a test
+ * require a live Postgres.
+ */
+export class Drizzle${entityPascal}Repository implements ${entityPascal}Repository {
+  constructor(private readonly db: () => NodePgDatabase) {}
+
+  async findAll(): Promise<${entityPascal}[]> {
+    return this.db().select().from(${camel});
+  }
+
+  async findById(id: string): Promise<${entityPascal} | undefined> {
+    const [row] = await this.db()
+      .select()
+      .from(${camel})
+      .where(eq(${camel}.id, id))
+      .limit(1);
+    return row;
+  }
+
+  async create(draft: ${entityPascal}Draft): Promise<${entityPascal}> {
+    const [row] = await this.db().insert(${camel}).values(draft).returning();
+    return row;
+  }
+
+  async update(
+    id: string,
+    patch: ${entityPascal}Patch,
+  ): Promise<${entityPascal} | undefined> {
+    const [row] = await this.db()
+      .update(${camel})
+      .set({ ...patch, updatedAt: new Date() })
+      .where(eq(${camel}.id, id))
+      .returning();
+    return row;
+  }
+
+  async remove(id: string): Promise<boolean> {
+    const rows = await this.db()
+      .delete(${camel})
+      .where(eq(${camel}.id, id))
+      .returning({ id: ${camel}.id });
+    return rows.length > 0;
+  }
+
+  async transaction<T>(
+    work: (repository: ${entityPascal}Repository) => Promise<T>,
+  ): Promise<T> {
+    return this.db().transaction((tx) =>
+      work(new Drizzle${entityPascal}Repository(() => tx)),
+    );
+  }
+}
+`;
+}
+
+/**
+ * The adapter's contract with Drizzle, proved against an in-memory double
+ * rather than a live Postgres: the rollback assertion is what a service's
+ * multi-write transaction depends on, and `nx test` has no database.
+ */
+function adapterSpecFile(names: ModuleNames): string {
+  const { entityPascal } = names;
+
+  return `import { describe, expect, it, vi } from 'vitest';
+import { Drizzle${entityPascal}Repository } from './${names.entityKebab}.adapter';
+
+interface FakeRow {
+  id: string;
+}
+
+/**
+ * A Drizzle stand-in, not a live database — nx test has no Postgres. It
+ * models exactly the two behaviours the port promises and the service
+ * layer relies on: a miss is an empty result set, and a throw inside
+ * transaction restores the pre-transaction rows.
+ */
+function fakeDb(rows: FakeRow[]) {
+  let staged = [...rows];
+  let nextId = 0;
+
+  const select = () => ({
+    from: () => {
+      const all = Promise.resolve(staged);
+      return Object.assign(all, {
+        where: () => ({ limit: () => Promise.resolve(staged.slice(0, 1)) }),
+      });
+    },
+  });
+
+  const insert = () => ({
+    values: (draft: Record<string, unknown>) => ({
+      returning: () => {
+        const row: FakeRow = { ...draft, id: \`generated-\${(nextId += 1)}\` };
+        staged = [...staged, row];
+        return Promise.resolve([row]);
+      },
+    }),
+  });
+
+  const update = () => ({
+    set: (patch: Record<string, unknown>) => ({
+      where: () => ({
+        returning: () =>
+          Promise.resolve(staged.length ? [{ ...staged[0], ...patch }] : []),
+      }),
+    }),
+  });
+
+  const remove = () => ({
+    where: () => ({
+      returning: () => {
+        const removed = staged.slice(0, 1);
+        staged = staged.slice(1);
+        return Promise.resolve(removed);
+      },
+    }),
+  });
+
+  async function transaction<T>(work: (tx: unknown) => Promise<T>): Promise<T> {
+    const snapshot = [...staged];
+    try {
+      return await work(db);
+    } catch (error) {
+      staged = snapshot;
+      throw error;
+    }
+  }
+
+  const db = { select, insert, update, delete: remove, transaction };
+
+  return {
+    db,
+    get rows(): FakeRow[] {
+      return staged;
+    },
+  };
+}
+
+describe('Drizzle${entityPascal}Repository', () => {
+  it('returns undefined rather than throwing when a row is absent', async () => {
+    const fake = fakeDb([]);
+    const repository = new Drizzle${entityPascal}Repository(
+      () => fake.db as never,
+    );
+
+    await expect(repository.findById('missing')).resolves.toBeUndefined();
+  });
+
+  it('reports a delete that matched nothing as false', async () => {
+    const fake = fakeDb([]);
+    const repository = new Drizzle${entityPascal}Repository(
+      () => fake.db as never,
+    );
+
+    await expect(repository.remove('missing')).resolves.toBe(false);
+  });
+
+  it('rolls every write back when the transaction body throws', async () => {
+    const fake = fakeDb([{ id: 'existing' }]);
+    const repository = new Drizzle${entityPascal}Repository(
+      () => fake.db as never,
+    );
+    const boom = new Error('second write failed');
+
+    await expect(
+      repository.transaction(async (tx) => {
+        await tx.create({} as never);
+        throw boom;
+      }),
+    ).rejects.toBe(boom);
+
+    expect(fake.rows).toHaveLength(1);
+  });
+
+  it('hands the transaction body a repository bound to that transaction', async () => {
+    const fake = fakeDb([{ id: 'existing' }]);
+    const repository = new Drizzle${entityPascal}Repository(
+      () => fake.db as never,
+    );
+    const seen = vi.fn();
+
+    await repository.transaction(async (tx) => {
+      seen(tx instanceof Drizzle${entityPascal}Repository);
+    });
+
+    expect(seen).toHaveBeenCalledWith(true);
+  });
+});
+`;
+}
+
+function barrelFile(names: ModuleNames): string {
+  return `export * from './lib/${names.entityKebab}.adapter';
+export * from './lib/${names.entityKebab}.port';
+`;
+}

package/workspace/tools/generators/repository/schema.json

@@ -0,0 +1,15 @@
+{
+  "$schema": "http://json-schema.org/schema",
+  "$id": "HedgehogRepositoryLayer",
+  "title": "Port, DI token, and Drizzle adapter for one domain module",
+  "type": "object",
+  "properties": {
+    "module": {
+      "type": "string",
+      "description": "Domain module name, plural kebab-case (e.g. tasks, order-items).",
+      "$default": { "$source": "argv", "index": 0 },
+      "x-prompt": "Domain module name (plural kebab-case)?"
+    }
+  },
+  "required": ["module"]
+}

package/workspace/tools/generators/schema/generator.ts

@@ -0,0 +1,169 @@
+import { formatFiles, Tree } from '@nx/devkit';
+import {
+  drizzleColumn,
+  drizzleImports,
+  Field,
+  isDateField,
+  parseFields,
+} from '../fields';
+import { moduleNames, ModuleNames } from '../naming';
+
+interface SchemaGeneratorOptions {
+  module: string;
+  fields: string;
+}
+
+export default async function schemaGenerator(
+  tree: Tree,
+  options: SchemaGeneratorOptions,
+) {
+  const names = moduleNames(options.module);
+  const fields = parseFields(options.fields);
+  const dir = `packages/db/src/schema/${names.module}`;
+
+  tree.write(`${dir}/${names.module}.table.ts`, tableFile(names, fields));
+  tree.write(`${dir}/${names.module}.zod.ts`, zodFile(names));
+  tree.write(`${dir}/index.ts`, barrelFile(names));
+  tree.write(`${dir}/${names.module}.spec.ts`, specFile(names, fields));
+
+  addSchemaBarrelExport(tree, names.module);
+
+  await formatFiles(tree);
+}
+
+function tableFile(names: ModuleNames, fields: Field[]): string {
+  const imports = drizzleImports(fields).join(', ');
+  const columns = fields.map((field) => `  ${drizzleColumn(field)}`).join('\n');
+
+  return `import { ${imports} } from 'drizzle-orm/pg-core';
+
+export const ${names.camel} = pgTable('${names.tableName}', {
+  id: uuid('id').primaryKey().defaultRandom(),
+${columns}
+  createdAt: timestamp('created_at', { mode: 'date', withTimezone: true })
+    .notNull()
+    .defaultNow(),
+  updatedAt: timestamp('updated_at', { mode: 'date', withTimezone: true })
+    .notNull()
+    .defaultNow(),
+});
+
+export type ${names.entityPascal} = typeof ${names.camel}.$inferSelect;
+export type New${names.entityPascal} = typeof ${names.camel}.$inferInsert;
+`;
+}
+
+function zodFile(names: ModuleNames): string {
+  return `import {
+  createInsertSchema,
+  createSelectSchema,
+  createUpdateSchema,
+} from 'drizzle-zod';
+import { ${names.camel} } from './${names.module}.table';
+
+export const select${names.entityPascal}Schema = createSelectSchema(${names.camel});
+export const insert${names.entityPascal}Schema = createInsertSchema(${names.camel});
+export const update${names.entityPascal}Schema = createUpdateSchema(${names.camel});
+`;
+}
+
+function barrelFile(names: ModuleNames): string {
+  return `export * from './${names.module}.table';
+export * from './${names.module}.zod';
+`;
+}
+
+function specFile(names: ModuleNames, fields: Field[]): string {
+  const columnAssertions = ['id', ...fields.map((field) => field.name)]
+    .map((name) => `    expect(columns).toContain('${name}');`)
+    .join('\n');
+  const dateField = fields.find(isDateField);
+
+  return `import { getTableColumns, getTableName } from 'drizzle-orm';
+import { describe, expect, it } from 'vitest';
+import {
+  ${names.camel},
+  insert${names.entityPascal}Schema,
+  select${names.entityPascal}Schema,
+} from './index';
+
+describe('${names.camel} schema', () => {
+  it('maps to the ${names.tableName} table with every declared column', () => {
+    const columns = Object.keys(getTableColumns(${names.camel}));
+
+    expect(getTableName(${names.camel})).toBe('${names.tableName}');
+${columnAssertions}
+    expect(columns).toContain('createdAt');
+    expect(columns).toContain('updatedAt');
+  });
+
+  it('derives a select schema that accepts a full row', () => {
+    const parsed = select${names.entityPascal}Schema.parse(${rowLiteral(names, fields)});
+
+    expect(parsed.id).toBe('${SAMPLE_UUID}');
+  });
+
+  it('derives an insert schema that rejects a row missing a required column', () => {
+    const result = insert${names.entityPascal}Schema.safeParse({});
+
+    expect(result.success).toBe(${fields.every((field) => field.nullable) ? 'true' : 'false'});
+  });${
+    dateField
+      ? `
+
+  it('reflects a timestamp column as a Date on the server side', () => {
+    const parsed = select${names.entityPascal}Schema.parse(${rowLiteral(names, fields)});
+
+    expect(parsed.${dateField.name}).toBeInstanceOf(Date);
+  });`
+      : ''
+  }
+});
+`;
+}
+
+const SAMPLE_UUID = '00000000-0000-4000-8000-000000000000';
+
+function rowLiteral(names: ModuleNames, fields: Field[]): string {
+  const entries = [
+    `id: '${SAMPLE_UUID}'`,
+    ...fields.map((field) => `${field.name}: ${sampleValue(field)}`),
+    'createdAt: new Date()',
+    'updatedAt: new Date()',
+  ];
+  return `{\n      ${entries.join(',\n      ')},\n    }`;
+}
+
+function sampleValue(field: Field): string {
+  const byType: Record<string, string> = {
+    string: `'sample'`,
+    text: `'sample'`,
+    boolean: 'false',
+    integer: '1',
+    timestamp: 'new Date()',
+  };
+  return byType[field.type] ?? 'null';
+}
+
+/**
+ * `packages/db/src/schema/index.ts` is a barrel-of-barrels every module's
+ * schema layer appends one line to (in scope — see core.yaml). Its shipped
+ * body is `export {};`, which is dropped once a real export exists.
+ */
+function addSchemaBarrelExport(tree: Tree, module: string) {
+  const barrelPath = 'packages/db/src/schema/index.ts';
+  const current = tree.read(barrelPath, 'utf-8') ?? '';
+  const line = `export * from './${module}/index';`;
+  if (current.includes(line)) return;
+
+  const lines = current
+    .split('\n')
+    .filter((entry) => entry.trim() !== 'export {};');
+  const exportLines = lines
+    .filter((entry) => entry.startsWith('export * from'))
+    .concat(line)
+    .sort();
+  const header = lines.filter((entry) => entry.startsWith('//'));
+
+  tree.write(barrelPath, `${[...header, '', ...exportLines].join('\n')}\n`);
+}

package/workspace/tools/generators/schema/schema.json

@@ -0,0 +1,20 @@
+{
+  "$schema": "http://json-schema.org/schema",
+  "$id": "HedgehogSchemaLayer",
+  "title": "Drizzle schema for one domain module",
+  "type": "object",
+  "properties": {
+    "module": {
+      "type": "string",
+      "description": "Domain module name, plural kebab-case (e.g. tasks, order-items).",
+      "$default": { "$source": "argv", "index": 0 },
+      "x-prompt": "Domain module name (plural kebab-case)?"
+    },
+    "fields": {
+      "type": "string",
+      "description": "Comma-separated name:type pairs; a trailing ? marks the column nullable, and string takes an optional length in parentheses (default 255). Types: string, text, boolean, integer, timestamp. Example: title:string(500),done:boolean,dueDate:timestamp?",
+      "x-prompt": "Fields (name:type, comma-separated)?"
+    }
+  },
+  "required": ["module", "fields"]
+}