create-projx 1.7.0 → 1.7.2

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

@@ -1,17 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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(),
-});

package/src/addons/orms/drizzle/shared/src/modules/_base/query-engine.ts

@@ -1,115 +0,0 @@
-import { type SQL, and, asc, desc, eq, ilike, or } from 'drizzle-orm';
-import type { PgTable } from 'drizzle-orm/pg-core';
-
-export interface ParsedQuery {
-  page: number;
-  page_size: number;
-  order_by?: string;
-  search?: string;
-  filters: Record<string, string>;
-}
-
-const RESERVED = new Set(['page', 'page_size', 'order_by', 'search']);
-
-export function parseRawQuery(rawQs: string): ParsedQuery {
-  const params = new URLSearchParams(rawQs);
-  const page = Math.max(1, Number(params.get('page')) || 1);
-  const page_size = Math.min(
-    100,
-    Math.max(1, Number(params.get('page_size')) || 10),
-  );
-  const filters: Record<string, string> = {};
-  for (const [key, value] of params.entries()) {
-    if (RESERVED.has(key)) continue;
-    filters[key] = value;
-  }
-  return {
-    page,
-    page_size,
-    order_by: params.get('order_by') ?? undefined,
-    search: params.get('search') ?? undefined,
-    filters,
-  };
-}
-
-function column(table: PgTable, key: string): unknown {
-  return (table as unknown as Record<string, unknown>)[key];
-}
-
-export function buildWhere(
-  table: PgTable,
-  filters: Record<string, string>,
-): SQL | undefined {
-  const clauses: SQL[] = [];
-  for (const [key, value] of Object.entries(filters)) {
-    const col = column(table, key);
-    if (!col) continue;
-    clauses.push(eq(col as Parameters<typeof eq>[0], value));
-  }
-  if (clauses.length === 0) return undefined;
-  if (clauses.length === 1) return clauses[0];
-  return and(...clauses);
-}
-
-export function buildSearchWhere(
-  table: PgTable,
-  searchableFields: string[],
-  term: string | undefined,
-): SQL | undefined {
-  if (!term) return undefined;
-  const trimmed = term.trim();
-  if (!trimmed) return undefined;
-  const pattern = `%${trimmed}%`;
-  const clauses: SQL[] = [];
-  for (const field of searchableFields) {
-    const col = column(table, field);
-    if (!col) continue;
-    clauses.push(ilike(col as Parameters<typeof ilike>[0], pattern));
-  }
-  if (clauses.length === 0) return undefined;
-  if (clauses.length === 1) return clauses[0];
-  return or(...clauses);
-}
-
-export function buildOrderBy(
-  table: PgTable,
-  orderBy: string | undefined,
-): SQL[] {
-  if (!orderBy) return [];
-  const out: SQL[] = [];
-  for (const raw of orderBy.split(',')) {
-    const term = raw.trim();
-    if (!term) continue;
-    const descOrder = term.startsWith('-');
-    const fieldName = descOrder ? term.slice(1) : term;
-    const col = column(table, fieldName);
-    if (!col) continue;
-    out.push((descOrder ? desc : asc)(col as Parameters<typeof asc>[0]));
-  }
-  return out;
-}
-
-export function combineWhere(a?: SQL, b?: SQL): SQL | undefined {
-  if (a && b) return and(a, b);
-  return a ?? b;
-}
-
-export interface PaginationMeta {
-  current_page: number;
-  page_size: number;
-  total_records: number;
-  total_pages: number;
-}
-
-export function buildPagination(
-  page: number,
-  page_size: number,
-  total: number,
-): PaginationMeta {
-  return {
-    current_page: page,
-    page_size,
-    total_records: total,
-    total_pages: Math.max(1, Math.ceil(total / page_size)),
-  };
-}

package/src/addons/orms/drizzle/shared/src/modules/_base/registry.ts

@@ -1,15 +0,0 @@
-export interface RegisteredEntity {
-  name: string;
-  apiPrefix: string;
-}
-
-const entityList: RegisteredEntity[] = [];
-
-export function registerInRegistry(entry: RegisteredEntity): void {
-  if (entityList.some((existing) => existing.name === entry.name)) return;
-  entityList.push(entry);
-}
-
-export function listEntities(): RegisteredEntity[] {
-  return [...entityList].sort((a, b) => a.name.localeCompare(b.name));
-}

package/src/addons/orms/sequelize/express/src/app.ts

@@ -1,82 +0,0 @@
-import crypto from 'node:crypto';
-import compression from 'compression';
-import cors from 'cors';
-import express, { type RequestHandler } from 'express';
-import rateLimit from 'express-rate-limit';
-import helmet from 'helmet';
-import pinoHttp from 'pino-http';
-import { allowedOrigins, config } from './config.js';
-import { ApiError, errorHandler, notFoundHandler } from './errors.js';
-import { checkDatabase, sequelize } from './db/client.js';
-import './models/index.js';
-import { listEntities } from './modules/_base/index.js';
-// projx-anchor: entity-imports
-
-const requestId: RequestHandler = (req, res, next) => {
-  const incoming = req.headers['x-request-id'];
-  const value =
-    typeof incoming === 'string' && incoming.trim()
-      ? incoming
-      : crypto.randomUUID();
-  res.locals.requestId = value;
-  res.setHeader('x-request-id', value);
-  next();
-};
-
-function corsOrigin(
-  origin: string | undefined,
-  callback: (err: Error | null, allow?: boolean) => void,
-): void {
-  const origins = allowedOrigins();
-  if (!origin || origins.includes('*') || origins.includes(origin)) {
-    callback(null, true);
-    return;
-  }
-  callback(new ApiError(403, 'Origin not allowed', 'origin_not_allowed'));
-}
-
-export function buildApp(): express.Express {
-  const app = express();
-
-  app.disable('x-powered-by');
-  app.locals.sequelize = sequelize;
-  app.use(requestId);
-  app.use(pinoHttp({ level: config.LOG_LEVEL }));
-  app.use(helmet());
-  app.use(cors({ origin: corsOrigin, credentials: true }));
-  app.use(compression());
-  app.use(express.json({ limit: '1mb' }));
-  app.use(express.urlencoded({ extended: false, limit: '1mb' }));
-  app.use(
-    rateLimit({
-      windowMs: config.RATE_LIMIT_WINDOW_MS,
-      limit: config.RATE_LIMIT_MAX,
-      standardHeaders: 'draft-8',
-      legacyHeaders: false,
-    }),
-  );
-
-  app.get('/api/health', async (_req, res) => {
-    const checks: Record<string, string> = { app: 'ok' };
-    try {
-      await checkDatabase();
-      checks.database = 'ok';
-    } catch (e) {
-      checks.database = `error: ${e instanceof Error ? e.message : String(e)}`;
-      res.status(503).json({ status: 'unhealthy', checks });
-      return;
-    }
-    res.json({ status: 'healthy', checks });
-  });
-
-  app.get('/api/v1/_meta', (_req, res) => {
-    res.json({ entities: listEntities(), orm: 'sequelize' });
-  });
-
-  // projx-anchor: entity-registrations
-
-  app.use(notFoundHandler);
-  app.use(errorHandler);
-
-  return app;
-}

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

@@ -1,226 +0,0 @@
-import express, {
-  type NextFunction,
-  type Request,
-  type Response,
-} from 'express';
-import type { Model, ModelStatic } from 'sequelize';
-import { ApiError } from '../../errors.js';
-import { registerInRegistry } from './registry.js';
-import {
-  buildOrder,
-  buildPagination,
-  buildSearchWhere,
-  buildWhere,
-  combineWhere,
-  parseRawQuery,
-} from './query-engine.js';
-
-export type BeforeCreateHook = (
-  request: Request,
-  data: Record<string, unknown>,
-) => void | Promise<void>;
-export type AfterCreateHook = (
-  request: Request,
-  record: Record<string, unknown>,
-) => void | Promise<void>;
-export type BeforeUpdateHook = (
-  request: Request,
-  response: Response,
-  data: Record<string, unknown>,
-) => void | Promise<void>;
-export type AfterUpdateHook = (
-  request: Request,
-  before: Record<string, unknown>,
-  after: Record<string, unknown>,
-) => void | Promise<void>;
-export type BeforeDeleteHook = (
-  request: Request,
-  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;
-}
-
-type AsyncHandler = (
-  req: Request,
-  res: Response,
-  next: NextFunction,
-) => Promise<void>;
-
-function asyncHandler(handler: AsyncHandler) {
-  return (req: Request, res: Response, next: NextFunction): void => {
-    handler(req, res, next).catch(next);
-  };
-}
-
-function attributes(model: ModelStatic<Model>): Set<string> {
-  return new Set(Object.keys(model.getAttributes()));
-}
-
-export function registerEntityRoutes(
-  config: SequelizeEntityConfig,
-): express.Router {
-  registerInRegistry({ name: config.name, apiPrefix: config.apiPrefix });
-  const router = express.Router();
-  const pk = config.primaryKey ?? 'id';
-  const attrs = attributes(config.model);
-
-  router.get(
-    '/',
-    asyncHandler(async (req, res) => {
-      const rawQs = req.originalUrl.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,
-      });
-      res.json({
-        data: rows.map((r) => r.toJSON()),
-        pagination: buildPagination(query.page, query.page_size, count),
-      });
-    }),
-  );
-
-  router.get(
-    '/:id',
-    asyncHandler(async (req, res) => {
-      const record = await config.model.findOne({
-        where: { [pk]: String(req.params.id) },
-      });
-      if (!record) throw new ApiError(404, 'Not found', 'not_found');
-      res.json(record.toJSON());
-    }),
-  );
-
-  if (config.readonly) return router;
-
-  router.post(
-    '/',
-    asyncHandler(async (req, res) => {
-      const data = req.body as Record<string, unknown>;
-      await config.beforeCreate?.(req, data);
-      const created = await config.model.create(data);
-      const record = created.toJSON() as Record<string, unknown>;
-      if (config.afterCreate) {
-        try {
-          await config.afterCreate(req, record);
-        } catch (err) {
-          req.log?.error?.(
-            {
-              err,
-              entity: config.name,
-              record_id: (record as { id?: string }).id,
-            },
-            'afterCreate hook failed (record persisted; hook is best-effort)',
-          );
-        }
-      }
-      res.status(201).json(record);
-    }),
-  );
-
-  router.patch(
-    '/:id',
-    asyncHandler(async (req, res) => {
-      const id = String(req.params.id);
-      const data = req.body as Record<string, unknown>;
-      if (!data || Object.keys(data).length === 0) {
-        throw new ApiError(400, 'Request body cannot be empty', 'empty_body');
-      }
-      if (config.beforeUpdate) {
-        await config.beforeUpdate(req, res, data);
-        if (res.headersSent) return;
-      }
-      const existing = await config.model.findOne({ where: { [pk]: id } });
-      if (!existing) throw new ApiError(404, 'Not found', 'not_found');
-      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(req, before, after);
-        } catch (err) {
-          req.log?.error?.(
-            { err, entity: config.name, record_id: id },
-            'afterUpdate hook failed (record persisted; hook is best-effort)',
-          );
-        }
-      }
-      res.json(after);
-    }),
-  );
-
-  router.delete(
-    '/:id',
-    asyncHandler(async (req, res) => {
-      const id = String(req.params.id);
-      if (config.beforeDelete) await config.beforeDelete(req, id);
-      const removed = await config.model.destroy({ where: { [pk]: id } });
-      if (removed === 0) throw new ApiError(404, 'Not found', 'not_found');
-      res.status(204).send();
-    }),
-  );
-
-  if (!config.bulkOperations) return router;
-
-  router.post(
-    '/bulk',
-    asyncHandler(async (req, res) => {
-      const { items } = req.body as { items: Record<string, unknown>[] };
-      if (!Array.isArray(items) || items.length === 0) {
-        throw new ApiError(
-          400,
-          'items must be a non-empty array',
-          'validation_error',
-        );
-      }
-      for (const item of items) {
-        await config.beforeCreate?.(req, item);
-      }
-      const rows = await config.model.bulkCreate(items);
-      res
-        .status(201)
-        .json({ data: rows.map((r) => r.toJSON()), count: rows.length });
-    }),
-  );
-
-  router.delete(
-    '/bulk',
-    asyncHandler(async (req, res) => {
-      const { ids } = req.body as { ids: string[] };
-      if (!Array.isArray(ids) || ids.length === 0) {
-        throw new ApiError(
-          400,
-          'ids must be a non-empty array',
-          'validation_error',
-        );
-      }
-      await config.model.destroy({ where: { [pk]: ids } });
-      res.status(204).send();
-    }),
-  );
-
-  return router;
-}

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

@@ -1,20 +0,0 @@
-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/express/src/server.ts

@@ -1,32 +0,0 @@
-import { createServer } from 'node:http';
-import { buildApp } from './app.js';
-import { config } from './config.js';
-import { closeDatabase } from './db/client.js';
-
-const app = buildApp();
-const server = createServer(app);
-
-server.listen(config.PORT, config.HOST, () => {
-  console.log(`Express API listening on http://${config.HOST}:${config.PORT}`);
-});
-
-function shutdown(signal: string): void {
-  console.log(`${signal} received, closing HTTP server`);
-  server.close((err) => {
-    closeDatabase()
-      .catch((closeErr: unknown) => {
-        console.error(closeErr);
-      })
-      .finally(() => {
-        if (err) {
-          console.error(err);
-          process.exit(1);
-        }
-        process.exit(0);
-      });
-  });
-  setTimeout(() => process.exit(1), 10_000).unref();
-}
-
-process.on('SIGTERM', shutdown);
-process.on('SIGINT', shutdown);

package/src/addons/orms/sequelize/express/tests/app.test.ts

@@ -1,24 +0,0 @@
-import request from 'supertest';
-import { describe, expect, it } from 'vitest';
-import { buildApp } from '../src/app.js';
-
-describe('Express Sequelize app', () => {
-  it('exposes empty generated metadata until entities are added', async () => {
-    const res = await request(buildApp()).get('/api/v1/_meta');
-
-    expect(res.status).toBe(200);
-    expect(res.body).toEqual({ entities: [], orm: 'sequelize' });
-  });
-
-  it('returns structured errors with request id', async () => {
-    const res = await request(buildApp())
-      .get('/missing')
-      .set('x-request-id', 'req-missing');
-
-    expect(res.status).toBe(404);
-    expect(res.body.error).toMatchObject({
-      code: 'not_found',
-      request_id: 'req-missing',
-    });
-  });
-});

package/src/addons/orms/sequelize/express/vitest.config.ts

@@ -1,20 +0,0 @@
-import { defineConfig } from 'vitest/config';
-
-export default defineConfig({
-  test: {
-    globals: true,
-    environment: 'node',
-    include: ['tests/**/*.test.ts'],
-    coverage: {
-      provider: 'v8',
-      include: ['src/**/*.ts'],
-      exclude: ['src/server.ts', 'src/config.ts'],
-      thresholds: {
-        statements: 80,
-        branches: 80,
-        functions: 80,
-        lines: 80,
-      },
-    },
-  },
-});

package/src/addons/orms/sequelize/fastify/src/app.ts

@@ -1,83 +0,0 @@
-import Fastify, { type FastifyInstance, type FastifyRequest } from 'fastify';
-import cors from '@fastify/cors';
-import helmet from '@fastify/helmet';
-import rateLimit from '@fastify/rate-limit';
-import { config } from './config.js';
-import errorHandler from './plugins/error-handler.js';
-import authPlugin from './plugins/auth.js';
-import authzPlugin from './plugins/authz.js';
-import requestIdPlugin from './plugins/request-id.js';
-import swaggerPlugin from './plugins/swagger.js';
-import { checkDatabase, closeDatabase, sequelize } from './db/client.js';
-import './models/index.js';
-import { listEntities } from './modules/_base/index.js';
-// projx-anchor: entity-imports
-
-export interface BuildAppOptions {
-  logger?: boolean | object;
-}
-
-export async function buildApp(
-  options: BuildAppOptions = {},
-): Promise<FastifyInstance> {
-  const app = Fastify({
-    logger: options.logger ?? { level: config.LOG_LEVEL },
-    genReqId: (req) =>
-      (req.headers['x-request-id'] as string) || crypto.randomUUID(),
-  });
-
-  app.decorate('sequelize', sequelize);
-  await app.register(helmet, { contentSecurityPolicy: false });
-  await app.register(cors, {
-    origin: config.CORS_ALLOW_ORIGINS.split(',').map((o) => o.trim()),
-    credentials: true,
-  });
-  await app.register(rateLimit, {
-    max: config.RATE_LIMIT_MAX,
-    timeWindow: config.RATE_LIMIT_WINDOW,
-    keyGenerator: (request: FastifyRequest) =>
-      request.authUser?.sub ?? request.ip,
-  });
-
-  await app.register(swaggerPlugin);
-  await app.register(errorHandler);
-  await app.register(requestIdPlugin);
-  await app.register(authPlugin);
-  await app.register(authzPlugin);
-
-  app.get(
-    '/api/health',
-    { config: { public: true }, schema: { tags: ['health'] } },
-    async (_request, reply) => {
-      const checks: Record<string, string> = { app: 'ok' };
-      try {
-        await checkDatabase();
-        checks.database = 'ok';
-      } catch (e) {
-        checks.database = `error: ${e instanceof Error ? e.message : String(e)}`;
-        return reply.status(503).send({ status: 'unhealthy', checks });
-      }
-      return reply.send({ status: 'healthy', checks });
-    },
-  );
-
-  app.get(
-    '/api/v1/_meta',
-    { config: { public: true }, schema: { tags: ['meta'] } },
-    async () => ({ entities: listEntities(), orm: 'sequelize' }),
-  );
-
-  // projx-anchor: entity-registrations
-
-  app.addHook('onClose', async () => {
-    await closeDatabase();
-  });
-
-  return app;
-}
-
-declare module 'fastify' {
-  interface FastifyInstance {
-    sequelize: typeof sequelize;
-  }
-}