create-projx 1.6.5 → 1.7.0

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

@@ -0,0 +1,216 @@
+import type { FastifyInstance, FastifyRequest, FastifyReply } from 'fastify';
+import type { Model, ModelStatic } from 'sequelize';
+import { registerInRegistry } from './registry.js';
+import {
+  buildOrder,
+  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 SequelizeEntityConfig {
+  name: string;
+  apiPrefix: string;
+  tag: string;
+  model: ModelStatic<Model>;
+  primaryKey?: string;
+  searchableFields?: string[];
+  readonly?: boolean;
+  bulkOperations?: boolean;
+  beforeCreate?: BeforeCreateHook;
+  afterCreate?: AfterCreateHook;
+  beforeUpdate?: BeforeUpdateHook;
+  afterUpdate?: AfterUpdateHook;
+  beforeDelete?: BeforeDeleteHook;
+}
+
+function attributes(model: ModelStatic<Model>): Set<string> {
+  return new Set(Object.keys(model.getAttributes()));
+}
+
+export function registerEntityRoutes(
+  app: FastifyInstance,
+  config: SequelizeEntityConfig,
+): void {
+  registerInRegistry({ name: config.name, apiPrefix: config.apiPrefix });
+  const pk = config.primaryKey ?? 'id';
+  const attrs = attributes(config.model);
+
+  app.get('/', { schema: { tags: [config.tag] } }, async (request, reply) => {
+    const rawQs = request.url.split('?')[1] ?? '';
+    const query = parseRawQuery(rawQs);
+    const filterWhere = buildWhere(attrs, query.filters);
+    const searchWhere = buildSearchWhere(
+      config.searchableFields ?? [],
+      query.search,
+    );
+    const where = combineWhere(filterWhere, searchWhere);
+    const order = buildOrder(attrs, query.order_by);
+    const { rows, count } = await config.model.findAndCountAll({
+      where,
+      order,
+      limit: query.page_size,
+      offset: (query.page - 1) * query.page_size,
+    });
+    return reply.send({
+      data: rows.map((r) => r.toJSON()),
+      pagination: buildPagination(query.page, query.page_size, count),
+    });
+  });
+
+  app.get(
+    '/:id',
+    { schema: { tags: [config.tag] } },
+    async (request, reply) => {
+      const { id } = request.params as { id: string };
+      const record = await config.model.findOne({ where: { [pk]: id } });
+      if (!record)
+        return reply
+          .status(404)
+          .send({ detail: 'Not found', request_id: request.id });
+      return reply.send(record.toJSON());
+    },
+  );
+
+  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 created = await config.model.create(data);
+    const record = created.toJSON() as Record<string, unknown>;
+    if (config.afterCreate) {
+      try {
+        await config.afterCreate(request, record);
+      } 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;
+      }
+      const existing = await config.model.findOne({ where: { [pk]: id } });
+      if (!existing)
+        return reply
+          .status(404)
+          .send({ detail: 'Not found', request_id: request.id });
+      const before = existing.toJSON() as Record<string, unknown>;
+      await existing.update(data);
+      const after = existing.toJSON() as Record<string, unknown>;
+      if (config.afterUpdate) {
+        try {
+          await config.afterUpdate(request, before, after);
+        } catch (err) {
+          request.log.error(
+            { err, entity: config.name, record_id: id },
+            'afterUpdate hook failed (record persisted; hook is best-effort)',
+          );
+        }
+      }
+      return reply.send(after);
+    },
+  );
+
+  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 removed = await config.model.destroy({ where: { [pk]: id } });
+      if (removed === 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 config.model.bulkCreate(items);
+      return reply
+        .status(201)
+        .send({ data: rows.map((r) => r.toJSON()), 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 config.model.destroy({ where: { [pk]: ids } });
+      return reply.status(204).send();
+    },
+  );
+}

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

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

package/src/addons/orms/sequelize/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 Sequelize 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: 'sequelize' });
+  });
+});

package/src/addons/orms/sequelize/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/sequelize/gen-entity/express-router.ts

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

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

@@ -0,0 +1,65 @@
+import { describe, it, expect, beforeAll, beforeEach, afterAll } from 'vitest';
+import request from 'supertest';
+import { buildApp } from '../src/app.js';
+import { __ENTITY_PASCAL__ } from '../src/models/__ENTITY_KEBAB__.js';
+import { sequelize, closeDatabase } from '../src/db/client.js';
+
+const app = buildApp();
+
+describe('__ENTITY_PASCAL__ CRUD', () => {
+  beforeAll(async () => {
+    await sequelize.sync({ force: true });
+  });
+
+  beforeEach(async () => {
+    await __ENTITY_PASCAL__.destroy({ where: {}, truncate: true });
+  });
+
+  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/sequelize/gen-entity/fastify-router.ts

@@ -0,0 +1,19 @@
+import type { FastifyInstance } from 'fastify';
+import { __ENTITY_PASCAL__ } from '../../models/__ENTITY_KEBAB__.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__',
+        model: __ENTITY_PASCAL__,
+        searchableFields: [__SEARCHABLE_FIELDS_ARRAY__],
+        bulkOperations: __BULK_OPERATIONS__,
+      });
+    },
+    { prefix: '/api/v1__API_PREFIX__' },
+  );
+}

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

@@ -0,0 +1,89 @@
+import { describe, it, expect, beforeAll, beforeEach, afterAll } from 'vitest';
+import type { FastifyInstance } from 'fastify';
+import { buildApp } from '../../src/app.js';
+import { __ENTITY_PASCAL__ } from '../../src/models/__ENTITY_KEBAB__.js';
+import { sequelize } from '../../src/db/client.js';
+
+describe('__ENTITY_PASCAL__ CRUD', () => {
+  let app: FastifyInstance;
+
+  beforeAll(async () => {
+    app = await buildApp({ logger: false });
+    await sequelize.sync({ force: true });
+    await app.ready();
+  });
+
+  beforeEach(async () => {
+    await __ENTITY_PASCAL__.destroy({ where: {}, truncate: true });
+  });
+
+  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/sequelize/gen-entity/model.ts

@@ -0,0 +1,21 @@
+import { DataTypes, Model } from 'sequelize';
+import { sequelize } from '../db/client.js';
+
+export class __ENTITY_PASCAL__ extends Model {
+  declare id: string;
+__FIELD_DECLARATIONS__
+  declare createdAt: Date;
+  declare updatedAt: Date;
+}
+
+__ENTITY_PASCAL__.init(
+  {
+    id: { type: DataTypes.UUID, defaultValue: DataTypes.UUIDV4, primaryKey: true },
+__FIELD_DEFINITIONS__
+  },
+  {
+    sequelize,
+    modelName: '__ENTITY_PASCAL__',
+    tableName: '__TABLE_NAME__',
+  },
+);

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

@@ -0,0 +1,53 @@
+{
+  "name": "sequelize",
+  "displayName": "Sequelize",
+  "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": "Sequelize" },
+    "removeDependencies": ["@prisma/client"],
+    "removeDevDependencies": ["prisma"],
+    "addDependencies": {
+      "sequelize": "^6.37.5",
+      "pg": "^8.16.3",
+      "pg-hstore": "^2.3.4"
+    },
+    "addDevDependencies": {
+      "@types/pg": "^8.15.5",
+      "sequelize-cli": "^6.6.3"
+    },
+    "removeScriptPrefixes": ["prisma:"],
+    "addScripts": {
+      "db:sync": "tsx scripts/db-sync.ts",
+      "db:migrate": "sequelize-cli db:migrate",
+      "db:migrate:undo": "sequelize-cli db:migrate:undo"
+    }
+  },
+  "dockerfile": {
+    "extraConfigFiles": [],
+    "migrateCommand": "tsx scripts/db-sync.ts"
+  }
+}

package/src/addons/orms/sequelize/shared/scripts/db-sync.ts

@@ -0,0 +1,14 @@
+import { sequelize } from '../src/db/client.js';
+import '../src/models/index.js';
+
+async function main(): Promise<void> {
+  await sequelize.authenticate();
+  await sequelize.sync({ alter: true });
+  console.log('Sequelize schema synced.');
+  await sequelize.close();
+}
+
+main().catch((err: unknown) => {
+  console.error('db-sync failed:', err);
+  process.exit(1);
+});

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

@@ -0,0 +1,19 @@
+import { Sequelize } from 'sequelize';
+import { config } from '../config.js';
+
+export const sequelize = new Sequelize(config.DATABASE_URL, {
+  dialect: 'postgres',
+  logging: false,
+  define: {
+    underscored: true,
+    timestamps: true,
+  },
+});
+
+export async function checkDatabase(): Promise<void> {
+  await sequelize.authenticate();
+}
+
+export async function closeDatabase(): Promise<void> {
+  await sequelize.close();
+}

package/src/addons/orms/sequelize/shared/src/models/index.ts

@@ -0,0 +1,9 @@
+// Aggregator for all Sequelize models. Each model module calls `Model.init(...)` at import
+// time, attaching itself to the shared sequelize instance from `../db/client.js`.
+// `gen entity` appends new model imports + exports below the anchors.
+
+// projx-anchor: model-imports
+
+export const models = {
+  // projx-anchor: model-exports
+};