create-projx 1.6.4 → 1.7.0

package/src/addons/orms/drizzle/fastify/src/modules/_base/auto-routes.ts

@@ -0,0 +1,268 @@
+import type { FastifyInstance, FastifyRequest, FastifyReply } from 'fastify';
+import { eq, inArray, sql } from 'drizzle-orm';
+import type { PgTable } from 'drizzle-orm/pg-core';
+import { registerInRegistry } from './registry.js';
+import {
+  buildOrderBy,
+  buildPagination,
+  buildSearchWhere,
+  buildWhere,
+  combineWhere,
+  parseRawQuery,
+} from './query-engine.js';
+
+export type BeforeCreateHook = (
+  request: FastifyRequest,
+  data: Record<string, unknown>,
+) => void | Promise<void>;
+export type AfterCreateHook = (
+  request: FastifyRequest,
+  record: Record<string, unknown>,
+) => void | Promise<void>;
+export type BeforeUpdateHook = (
+  request: FastifyRequest,
+  reply: FastifyReply,
+  data: Record<string, unknown>,
+) => void | Promise<void>;
+export type AfterUpdateHook = (
+  request: FastifyRequest,
+  before: Record<string, unknown>,
+  after: Record<string, unknown>,
+) => void | Promise<void>;
+export type BeforeDeleteHook = (
+  request: FastifyRequest,
+  recordId: string,
+) => void | Promise<void>;
+
+export interface DrizzleEntityConfig {
+  name: string;
+  apiPrefix: string;
+  tag: string;
+  table: PgTable;
+  primaryKey?: string;
+  searchableFields?: string[];
+  readonly?: boolean;
+  bulkOperations?: boolean;
+  beforeCreate?: BeforeCreateHook;
+  afterCreate?: AfterCreateHook;
+  beforeUpdate?: BeforeUpdateHook;
+  afterUpdate?: AfterUpdateHook;
+  beforeDelete?: BeforeDeleteHook;
+}
+
+function column(table: PgTable, key: string): unknown {
+  return (table as unknown as Record<string, unknown>)[key];
+}
+
+function pkColumn(config: DrizzleEntityConfig): unknown {
+  const key = config.primaryKey ?? 'id';
+  const col = column(config.table, key);
+  if (!col) {
+    throw new Error(
+      `Primary key column "${key}" not found on table ${config.name}`,
+    );
+  }
+  return col;
+}
+
+export function registerEntityRoutes(
+  app: FastifyInstance,
+  config: DrizzleEntityConfig,
+): void {
+  registerInRegistry({ name: config.name, apiPrefix: config.apiPrefix });
+  const pk = pkColumn(config) as Parameters<typeof eq>[0];
+
+  app.get('/', { schema: { tags: [config.tag] } }, async (request, reply) => {
+    const rawQs = request.url.split('?')[1] ?? '';
+    const query = parseRawQuery(rawQs);
+    const filterWhere = buildWhere(config.table, query.filters);
+    const searchWhere = buildSearchWhere(
+      config.table,
+      config.searchableFields ?? [],
+      query.search,
+    );
+    const where = combineWhere(filterWhere, searchWhere);
+    const order = buildOrderBy(config.table, query.order_by);
+    const offset = (query.page - 1) * query.page_size;
+
+    const baseSelect = app.db.select().from(config.table);
+    const baseCount = app.db
+      .select({ count: sql<number>`count(*)::int` })
+      .from(config.table);
+
+    const rows = await (where
+      ? baseSelect
+          .where(where)
+          .orderBy(...order)
+          .limit(query.page_size)
+          .offset(offset)
+      : baseSelect
+          .orderBy(...order)
+          .limit(query.page_size)
+          .offset(offset));
+    const [{ count }] = await (where ? baseCount.where(where) : baseCount);
+
+    return reply.send({
+      data: rows,
+      pagination: buildPagination(query.page, query.page_size, Number(count)),
+    });
+  });
+
+  app.get(
+    '/:id',
+    { schema: { tags: [config.tag] } },
+    async (request, reply) => {
+      const { id } = request.params as { id: string };
+      const [record] = await app.db
+        .select()
+        .from(config.table)
+        .where(eq(pk, id))
+        .limit(1);
+      if (!record)
+        return reply
+          .status(404)
+          .send({ detail: 'Not found', request_id: request.id });
+      return reply.send(record);
+    },
+  );
+
+  if (config.readonly) return;
+
+  app.post('/', { schema: { tags: [config.tag] } }, async (request, reply) => {
+    const data = request.body as Record<string, unknown>;
+    await config.beforeCreate?.(request, data);
+    const [record] = await app.db
+      .insert(config.table)
+      .values(data as never)
+      .returning();
+    if (config.afterCreate) {
+      try {
+        await config.afterCreate(request, record as Record<string, unknown>);
+      } catch (err) {
+        request.log.error(
+          {
+            err,
+            entity: config.name,
+            record_id: (record as { id?: string }).id,
+          },
+          'afterCreate hook failed (record persisted; hook is best-effort)',
+        );
+      }
+    }
+    return reply.status(201).send(record);
+  });
+
+  app.patch(
+    '/:id',
+    { schema: { tags: [config.tag] } },
+    async (request, reply) => {
+      const { id } = request.params as { id: string };
+      const data = request.body as Record<string, unknown>;
+      if (!data || Object.keys(data).length === 0) {
+        return reply.status(400).send({
+          detail: 'Request body cannot be empty',
+          request_id: request.id,
+        });
+      }
+      if (config.beforeUpdate) {
+        await config.beforeUpdate(request, reply, data);
+        if (reply.sent) return;
+      }
+      let before: Record<string, unknown> | null = null;
+      if (config.afterUpdate) {
+        const [existing] = await app.db
+          .select()
+          .from(config.table)
+          .where(eq(pk, id))
+          .limit(1);
+        before = (existing as Record<string, unknown>) ?? null;
+      }
+      const [record] = await app.db
+        .update(config.table)
+        .set(data as never)
+        .where(eq(pk, id))
+        .returning();
+      if (!record) {
+        return reply
+          .status(404)
+          .send({ detail: 'Not found', request_id: request.id });
+      }
+      if (config.afterUpdate && before) {
+        try {
+          await config.afterUpdate(
+            request,
+            before,
+            record as Record<string, unknown>,
+          );
+        } catch (err) {
+          request.log.error(
+            { err, entity: config.name, record_id: id },
+            'afterUpdate hook failed (record persisted; hook is best-effort)',
+          );
+        }
+      }
+      return reply.send(record);
+    },
+  );
+
+  app.delete(
+    '/:id',
+    { schema: { tags: [config.tag] } },
+    async (request, reply) => {
+      const { id } = request.params as { id: string };
+      if (config.beforeDelete) await config.beforeDelete(request, id);
+      const deleted = await app.db
+        .delete(config.table)
+        .where(eq(pk, id))
+        .returning();
+      if (deleted.length === 0) {
+        return reply
+          .status(404)
+          .send({ detail: 'Not found', request_id: request.id });
+      }
+      return reply.status(204).send();
+    },
+  );
+
+  if (!config.bulkOperations) return;
+
+  app.post(
+    '/bulk',
+    { schema: { tags: [config.tag] } },
+    async (request, reply) => {
+      const { items } = request.body as { items: Record<string, unknown>[] };
+      if (!Array.isArray(items) || items.length === 0) {
+        return reply.status(400).send({
+          detail: 'items must be a non-empty array',
+          request_id: request.id,
+        });
+      }
+      for (const item of items) {
+        await config.beforeCreate?.(request, item);
+      }
+      const rows = await app.db
+        .insert(config.table)
+        .values(items as never)
+        .returning();
+      return reply.status(201).send({ data: rows, count: rows.length });
+    },
+  );
+
+  app.delete(
+    '/bulk',
+    { schema: { tags: [config.tag] } },
+    async (request, reply) => {
+      const { ids } = request.body as { ids: string[] };
+      if (!Array.isArray(ids) || ids.length === 0) {
+        return reply.status(400).send({
+          detail: 'ids must be a non-empty array',
+          request_id: request.id,
+        });
+      }
+      await app.db
+        .delete(config.table)
+        .where(inArray(pk as Parameters<typeof inArray>[0], ids));
+      return reply.status(204).send();
+    },
+  );
+}

package/src/addons/orms/drizzle/fastify/src/modules/_base/index.ts

@@ -0,0 +1,20 @@
+export { registerEntityRoutes } from './auto-routes.js';
+export type {
+  DrizzleEntityConfig,
+  BeforeCreateHook,
+  AfterCreateHook,
+  BeforeUpdateHook,
+  AfterUpdateHook,
+  BeforeDeleteHook,
+} from './auto-routes.js';
+export { listEntities, registerInRegistry } from './registry.js';
+export type { RegisteredEntity } from './registry.js';
+export {
+  buildOrderBy,
+  buildPagination,
+  buildSearchWhere,
+  buildWhere,
+  combineWhere,
+  parseRawQuery,
+} from './query-engine.js';
+export type { ParsedQuery, PaginationMeta } from './query-engine.js';

package/src/addons/orms/drizzle/fastify/tests/modules/app.test.ts

@@ -0,0 +1,20 @@
+import { describe, expect, it, afterEach } from 'vitest';
+import type { FastifyInstance } from 'fastify';
+import { buildApp } from '../../src/app.js';
+
+describe('Fastify Drizzle app', () => {
+  let app: FastifyInstance | undefined;
+
+  afterEach(async () => {
+    await app?.close();
+    app = undefined;
+  });
+
+  it('exposes empty generated metadata until entities are added', async () => {
+    app = await buildApp({ logger: false });
+    const res = await app.inject({ method: 'GET', url: '/api/v1/_meta' });
+
+    expect(res.statusCode).toBe(200);
+    expect(res.json()).toEqual({ entities: [], orm: 'drizzle' });
+  });
+});

package/src/addons/orms/drizzle/fastify/vitest.config.ts

@@ -0,0 +1,31 @@
+import { defineConfig } from 'vitest/config';
+import { config } from 'dotenv';
+
+config({ path: '.env.test' });
+
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: 'node',
+    include: ['tests/**/*.test.ts'],
+    coverage: {
+      provider: 'v8',
+      include: ['src/**/*.ts'],
+      exclude: [
+        'src/server.ts',
+        'src/app.ts',
+        'src/config.ts',
+        'src/plugins/swagger.ts',
+      ],
+      thresholds: {
+        statements: 80,
+        branches: 80,
+        functions: 80,
+        lines: 80,
+      },
+    },
+    pool: 'forks',
+    testTimeout: 15000,
+    hookTimeout: 15000,
+  },
+});

package/src/addons/orms/drizzle/gen-entity/express-router.ts

@@ -0,0 +1,21 @@
+import type { Express } from 'express';
+import type { DbClient } from '../../db/client.js';
+import { __TABLE_CAMEL__ } from '../../db/schema.js';
+import { registerEntityRoutes } from '../_base/index.js';
+
+export function register__ENTITY_PASCAL__Entity(app: Express, db: DbClient): void {
+  app.use(
+    '/api/v1__API_PREFIX__',
+    registerEntityRoutes(
+      {
+        name: '__ENTITY_PASCAL__',
+        apiPrefix: '__API_PREFIX__',
+        tag: '__TAG__',
+        table: __TABLE_CAMEL__,
+        searchableFields: [__SEARCHABLE_FIELDS_ARRAY__],
+        bulkOperations: __BULK_OPERATIONS__,
+      },
+      db,
+    ),
+  );
+}

package/src/addons/orms/drizzle/gen-entity/express-test.ts

@@ -0,0 +1,61 @@
+import { describe, it, expect, beforeEach, afterAll } from 'vitest';
+import request from 'supertest';
+import { buildApp } from '../src/app.js';
+import { db, closeDatabase } from '../src/db/client.js';
+import { __TABLE_CAMEL__ } from '../src/db/schema.js';
+
+const app = buildApp();
+
+describe('__ENTITY_PASCAL__ CRUD', () => {
+  beforeEach(async () => {
+    await db.delete(__TABLE_CAMEL__);
+  });
+
+  afterAll(async () => {
+    await closeDatabase();
+  });
+
+  it('POST creates a record', async () => {
+    const res = await request(app).post('/api/v1__API_PREFIX__').send(__SAMPLE_PAYLOAD__);
+    expect(res.status).toBe(201);
+    expect(res.body).toMatchObject(__SAMPLE_PAYLOAD__);
+  });
+
+  it('GET / lists records with pagination', async () => {
+    await request(app).post('/api/v1__API_PREFIX__').send(__SAMPLE_PAYLOAD__);
+    const res = await request(app).get('/api/v1__API_PREFIX__');
+    expect(res.status).toBe(200);
+    expect(res.body.data).toHaveLength(1);
+    expect(res.body.pagination).toMatchObject({ current_page: 1, total_records: 1 });
+  });
+
+  it('GET /:id returns one record', async () => {
+    const created = await request(app).post('/api/v1__API_PREFIX__').send(__SAMPLE_PAYLOAD__);
+    const { id } = created.body as { id: string };
+    const res = await request(app).get(`/api/v1__API_PREFIX__/${id}`);
+    expect(res.status).toBe(200);
+  });
+
+  it('GET /:id returns 404 when not found', async () => {
+    const res = await request(app).get(
+      '/api/v1__API_PREFIX__/00000000-0000-0000-0000-000000000000',
+    );
+    expect(res.status).toBe(404);
+  });
+
+  it('PATCH /:id updates a record', async () => {
+    const created = await request(app).post('/api/v1__API_PREFIX__').send(__SAMPLE_PAYLOAD__);
+    const { id } = created.body as { id: string };
+    const res = await request(app).patch(`/api/v1__API_PREFIX__/${id}`).send(__UPDATE_PAYLOAD__);
+    expect(res.status).toBe(200);
+  });
+
+  it('DELETE /:id removes a record', async () => {
+    const created = await request(app).post('/api/v1__API_PREFIX__').send(__SAMPLE_PAYLOAD__);
+    const { id } = created.body as { id: string };
+    const del = await request(app).delete(`/api/v1__API_PREFIX__/${id}`);
+    expect(del.status).toBe(204);
+    const get = await request(app).get(`/api/v1__API_PREFIX__/${id}`);
+    expect(get.status).toBe(404);
+  });
+});

package/src/addons/orms/drizzle/gen-entity/fastify-router.ts

@@ -0,0 +1,19 @@
+import type { FastifyInstance } from 'fastify';
+import { __TABLE_CAMEL__ } from '../../db/schema.js';
+import { registerEntityRoutes } from '../_base/index.js';
+
+export async function register__ENTITY_PASCAL__Entity(app: FastifyInstance): Promise<void> {
+  await app.register(
+    async (instance) => {
+      registerEntityRoutes(instance, {
+        name: '__ENTITY_PASCAL__',
+        apiPrefix: '__API_PREFIX__',
+        tag: '__TAG__',
+        table: __TABLE_CAMEL__,
+        searchableFields: [__SEARCHABLE_FIELDS_ARRAY__],
+        bulkOperations: __BULK_OPERATIONS__,
+      });
+    },
+    { prefix: '/api/v1__API_PREFIX__' },
+  );
+}

package/src/addons/orms/drizzle/gen-entity/fastify-test.ts

@@ -0,0 +1,87 @@
+import { describe, it, expect, beforeAll, beforeEach, afterAll } from 'vitest';
+import type { FastifyInstance } from 'fastify';
+import { buildApp } from '../../src/app.js';
+import { __TABLE_CAMEL__ } from '../../src/db/schema.js';
+
+describe('__ENTITY_PASCAL__ CRUD', () => {
+  let app: FastifyInstance;
+
+  beforeAll(async () => {
+    app = await buildApp({ logger: false });
+    await app.ready();
+  });
+
+  beforeEach(async () => {
+    await app.db.delete(__TABLE_CAMEL__);
+  });
+
+  afterAll(async () => {
+    await app.close();
+  });
+
+  it('POST creates a record', async () => {
+    const res = await app.inject({
+      method: 'POST',
+      url: '/api/v1__API_PREFIX__',
+      payload: __SAMPLE_PAYLOAD__,
+    });
+    expect(res.statusCode).toBe(201);
+    expect(res.json()).toMatchObject(__SAMPLE_PAYLOAD__);
+  });
+
+  it('GET / lists records with pagination', async () => {
+    await app.inject({ method: 'POST', url: '/api/v1__API_PREFIX__', payload: __SAMPLE_PAYLOAD__ });
+    const res = await app.inject({ method: 'GET', url: '/api/v1__API_PREFIX__' });
+    expect(res.statusCode).toBe(200);
+    const body = res.json();
+    expect(body.data).toHaveLength(1);
+    expect(body.pagination).toMatchObject({ current_page: 1, total_records: 1 });
+  });
+
+  it('GET /:id returns one record', async () => {
+    const created = await app.inject({
+      method: 'POST',
+      url: '/api/v1__API_PREFIX__',
+      payload: __SAMPLE_PAYLOAD__,
+    });
+    const { id } = created.json() as { id: string };
+    const res = await app.inject({ method: 'GET', url: `/api/v1__API_PREFIX__/${id}` });
+    expect(res.statusCode).toBe(200);
+  });
+
+  it('GET /:id returns 404 when not found', async () => {
+    const res = await app.inject({
+      method: 'GET',
+      url: '/api/v1__API_PREFIX__/00000000-0000-0000-0000-000000000000',
+    });
+    expect(res.statusCode).toBe(404);
+  });
+
+  it('PATCH /:id updates a record', async () => {
+    const created = await app.inject({
+      method: 'POST',
+      url: '/api/v1__API_PREFIX__',
+      payload: __SAMPLE_PAYLOAD__,
+    });
+    const { id } = created.json() as { id: string };
+    const res = await app.inject({
+      method: 'PATCH',
+      url: `/api/v1__API_PREFIX__/${id}`,
+      payload: __UPDATE_PAYLOAD__,
+    });
+    expect(res.statusCode).toBe(200);
+  });
+
+  it('DELETE /:id removes a record', async () => {
+    const created = await app.inject({
+      method: 'POST',
+      url: '/api/v1__API_PREFIX__',
+      payload: __SAMPLE_PAYLOAD__,
+    });
+    const { id } = created.json() as { id: string };
+    const del = await app.inject({ method: 'DELETE', url: `/api/v1__API_PREFIX__/${id}` });
+    expect(del.statusCode).toBe(204);
+    const get = await app.inject({ method: 'GET', url: `/api/v1__API_PREFIX__/${id}` });
+    expect(get.statusCode).toBe(404);
+  });
+});

package/src/addons/orms/drizzle/manifest.json

@@ -0,0 +1,52 @@
+{
+  "name": "drizzle",
+  "displayName": "Drizzle",
+  "frameworks": ["fastify", "express"],
+  "removeFromBase": [
+    "prisma",
+    "src/plugins/prisma.ts",
+    "src/prisma.ts",
+    "src/lib/service-config.ts",
+    "src/modules/_base",
+    "src/modules/audit-logs",
+    "tests/modules/audit-logs.test.ts",
+    "tests/modules/audit-middleware.test.ts",
+    "tests/modules/auto-routes.test.ts",
+    "tests/modules/entity-validation.test.ts",
+    "tests/modules/expand.test.ts",
+    "tests/modules/field-privacy.test.ts",
+    "tests/modules/meta.test.ts",
+    "tests/modules/query-engine.test.ts",
+    "tests/modules/repository.test.ts",
+    "tests/modules/service.test.ts",
+    "tests/helpers/crud-test-base.ts",
+    "tests/helpers/crud-test-base.test.ts",
+    "tests/helpers/migration-checksum.ts",
+    "tests/helpers/migration-checksum.test.ts",
+    "tests/global-setup.ts",
+    "tests"
+  ],
+  "packageOverrides": {
+    "descriptionReplace": { "from": "Prisma", "to": "Drizzle" },
+    "removeDependencies": ["@prisma/client"],
+    "removeDevDependencies": ["prisma"],
+    "addDependencies": {
+      "drizzle-orm": "^0.44.5",
+      "pg": "^8.16.3"
+    },
+    "addDevDependencies": {
+      "@types/pg": "^8.15.5",
+      "drizzle-kit": "^0.31.4"
+    },
+    "removeScriptPrefixes": ["prisma:"],
+    "addScripts": {
+      "db:generate": "drizzle-kit generate",
+      "db:migrate": "drizzle-kit migrate",
+      "db:push": "drizzle-kit push"
+    }
+  },
+  "dockerfile": {
+    "extraConfigFiles": ["drizzle.config.ts"],
+    "migrateCommand": "drizzle-kit push --force"
+  }
+}

package/src/addons/orms/drizzle/shared/drizzle.config.ts

@@ -0,0 +1,12 @@
+import { defineConfig } from 'drizzle-kit';
+
+export default defineConfig({
+  schema: './src/db/schema.ts',
+  out: './drizzle',
+  dialect: 'postgresql',
+  dbCredentials: {
+    url: process.env.DATABASE_URL ?? '',
+  },
+  strict: true,
+  verbose: true,
+});

package/src/addons/orms/drizzle/shared/src/db/client.ts

@@ -0,0 +1,17 @@
+import { drizzle } from 'drizzle-orm/node-postgres';
+import { Pool } from 'pg';
+import { config } from '../config.js';
+import * as schema from './schema.js';
+
+export const pool = new Pool({ connectionString: config.DATABASE_URL });
+export const db = drizzle(pool, { schema });
+
+export async function checkDatabase(): Promise<void> {
+  await pool.query('SELECT 1');
+}
+
+export async function closeDatabase(): Promise<void> {
+  await pool.end();
+}
+
+export type DbClient = typeof db;

package/src/addons/orms/drizzle/shared/src/db/schema.ts

@@ -0,0 +1,14 @@
+import { jsonb, pgTable, text, timestamp, uuid } from 'drizzle-orm/pg-core';
+
+export const auditLogs = pgTable('audit_logs', {
+  id: uuid('id').primaryKey().defaultRandom(),
+  tableName: text('table_name').notNull(),
+  recordId: text('record_id').notNull(),
+  action: text('action').notNull(),
+  oldValue: jsonb('old_value'),
+  newValue: jsonb('new_value'),
+  performedBy: text('performed_by').notNull().default('system'),
+  createdAt: timestamp('created_at', { withTimezone: true })
+    .notNull()
+    .defaultNow(),
+});