create-projx 1.7.0 → 1.7.1

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

@@ -1,101 +0,0 @@
-import { Op, type Order, type WhereOptions } from 'sequelize';
-
-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,
-  };
-}
-
-export function buildWhere(
-  attributes: Set<string>,
-  filters: Record<string, string>,
-): WhereOptions {
-  const where: Record<string, unknown> = {};
-  for (const [key, value] of Object.entries(filters)) {
-    if (!attributes.has(key)) continue;
-    where[key] = value;
-  }
-  return where as WhereOptions;
-}
-
-export function buildSearchWhere(
-  searchableFields: string[],
-  term: string | undefined,
-): WhereOptions | undefined {
-  if (!term) return undefined;
-  const trimmed = term.trim();
-  if (!trimmed || searchableFields.length === 0) return undefined;
-  const pattern = `%${trimmed}%`;
-  return {
-    [Op.or]: searchableFields.map((field) => ({
-      [field]: { [Op.iLike]: pattern },
-    })),
-  } as WhereOptions;
-}
-
-export function combineWhere(a: WhereOptions, b?: WhereOptions): WhereOptions {
-  if (!b) return a;
-  return { [Op.and]: [a, b] } as WhereOptions;
-}
-
-export function buildOrder(
-  attributes: Set<string>,
-  orderBy: string | undefined,
-): Order | undefined {
-  if (!orderBy) return undefined;
-  const out: [string, 'ASC' | 'DESC'][] = [];
-  for (const raw of orderBy.split(',')) {
-    const term = raw.trim();
-    if (!term) continue;
-    const descOrder = term.startsWith('-');
-    const fieldName = descOrder ? term.slice(1) : term;
-    if (!attributes.has(fieldName)) continue;
-    out.push([fieldName, descOrder ? 'DESC' : 'ASC']);
-  }
-  return out.length > 0 ? (out as Order) : undefined;
-}
-
-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/sequelize/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/typeorm/express/src/app.ts

@@ -1,82 +0,0 @@
-import 'reflect-metadata';
-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, dataSource } from './db/data-source.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.dataSource = dataSource;
-  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: 'typeorm' });
-  });
-
-  // projx-anchor: entity-registrations
-
-  app.use(notFoundHandler);
-  app.use(errorHandler);
-
-  return app;
-}

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

@@ -1,249 +0,0 @@
-import express, {
-  type NextFunction,
-  type Request,
-  type Response,
-} from 'express';
-import type {
-  DeepPartial,
-  EntityTarget,
-  ObjectLiteral,
-  Repository,
-} from 'typeorm';
-import { dataSource } from '../../db/data-source.js';
-import { ApiError } from '../../errors.js';
-import { registerInRegistry } from './registry.js';
-import {
-  buildOrder,
-  buildPagination,
-  buildSearchWheres,
-  buildWhere,
-  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 TypeormEntityConfig<T extends ObjectLiteral> {
-  name: string;
-  apiPrefix: string;
-  tag: string;
-  entity: EntityTarget<T>;
-  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 columnNames<T extends ObjectLiteral>(
-  repo: Repository<T>,
-): Set<string> {
-  return new Set(repo.metadata.columns.map((c) => c.propertyName));
-}
-
-export function registerEntityRoutes<T extends ObjectLiteral>(
-  config: TypeormEntityConfig<T>,
-): express.Router {
-  registerInRegistry({ name: config.name, apiPrefix: config.apiPrefix });
-  const router = express.Router();
-  const pk = config.primaryKey ?? 'id';
-
-  function repo(): Repository<T> {
-    return dataSource.getRepository(config.entity);
-  }
-
-  router.get(
-    '/',
-    asyncHandler(async (req, res) => {
-      const rawQs = req.originalUrl.split('?')[1] ?? '';
-      const query = parseRawQuery(rawQs);
-      const r = repo();
-      const cols = columnNames(r);
-      const filterWhere = buildWhere<T>(cols, query.filters);
-      const searchWheres = buildSearchWheres<T>(
-        config.searchableFields ?? [],
-        query.search,
-      );
-      const where =
-        searchWheres.length > 0
-          ? searchWheres.map((s) => ({ ...filterWhere, ...s }))
-          : filterWhere;
-      const order = buildOrder<T>(cols, query.order_by);
-      const [rows, count] = await r.findAndCount({
-        where,
-        order,
-        skip: (query.page - 1) * query.page_size,
-        take: query.page_size,
-      });
-      res.json({
-        data: rows,
-        pagination: buildPagination(query.page, query.page_size, count),
-      });
-    }),
-  );
-
-  router.get(
-    '/:id',
-    asyncHandler(async (req, res) => {
-      const record = await repo().findOne({
-        where: { [pk]: String(req.params.id) } as never,
-      });
-      if (!record) throw new ApiError(404, 'Not found', 'not_found');
-      res.json(record);
-    }),
-  );
-
-  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 r = repo();
-      const entity = r.create(data as DeepPartial<T>);
-      const record = (await r.save(entity)) as unknown 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 r = repo();
-      const existing = await r.findOne({ where: { [pk]: id } as never });
-      if (!existing) throw new ApiError(404, 'Not found', 'not_found');
-      const before = { ...(existing as Record<string, unknown>) };
-      Object.assign(existing, data);
-      const saved = (await r.save(existing)) as Record<string, unknown>;
-      if (config.afterUpdate) {
-        try {
-          await config.afterUpdate(req, before, saved);
-        } catch (err) {
-          req.log?.error?.(
-            { err, entity: config.name, record_id: id },
-            'afterUpdate hook failed (record persisted; hook is best-effort)',
-          );
-        }
-      }
-      res.json(saved);
-    }),
-  );
-
-  router.delete(
-    '/:id',
-    asyncHandler(async (req, res) => {
-      const id = String(req.params.id);
-      if (config.beforeDelete) await config.beforeDelete(req, id);
-      const result = await repo().delete({ [pk]: id } as never);
-      if (!result.affected) 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 r = repo();
-      const entities = r.create(items as DeepPartial<T>[]);
-      const rows = (await r.save(entities)) as unknown as Record<
-        string,
-        unknown
-      >[];
-      res.status(201).json({ data: rows, 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 repo().delete(ids as never);
-      res.status(204).send();
-    }),
-  );
-
-  return router;
-}

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

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

package/src/addons/orms/typeorm/express/src/server.ts

@@ -1,43 +0,0 @@
-import 'reflect-metadata';
-import { createServer } from 'node:http';
-import { buildApp } from './app.js';
-import { config } from './config.js';
-import { closeDatabase, dataSource } from './db/data-source.js';
-
-async function main(): Promise<void> {
-  if (!dataSource.isInitialized) await dataSource.initialize();
-  const app = buildApp();
-  const server = createServer(app);
-
-  server.listen(config.PORT, config.HOST, () => {
-    console.log(
-      `Express API listening on http://${config.HOST}:${config.PORT}`,
-    );
-  });
-
-  const 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);
-}
-
-main().catch((err: unknown) => {
-  console.error('Failed to start server:', err);
-  process.exit(1);
-});

package/src/addons/orms/typeorm/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 TypeORM 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: 'typeorm' });
-  });
-
-  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/typeorm/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/typeorm/fastify/src/app.ts

@@ -1,86 +0,0 @@
-import 'reflect-metadata';
-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, dataSource } from './db/data-source.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(),
-  });
-
-  if (!dataSource.isInitialized) {
-    await dataSource.initialize();
-  }
-  app.decorate('dataSource', dataSource);
-  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: 'typeorm' }),
-  );
-
-  // projx-anchor: entity-registrations
-
-  app.addHook('onClose', async () => {
-    await closeDatabase();
-  });
-
-  return app;
-}
-
-declare module 'fastify' {
-  interface FastifyInstance {
-    dataSource: typeof dataSource;
-  }
-}