@martel/calyx 1.8.0 → 1.9.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@martel/calyx",
-  "version": "1.8.0",
+  "version": "1.9.0",
   "description": "High-performance Bun-native NestJS-compatible framework",
   "main": "src/index.ts",
   "bin": {
@@ -19,15 +19,16 @@
     "@nestjs/common": "^11.1.27",
     "@nestjs/core": "^11.1.27",
     "@nestjs/platform-express": "^11.1.27",
+    "@nestjs/swagger": "^11.4.5",
+    "@semantic-release/changelog": "^6.0.3",
+    "@semantic-release/git": "^10.0.1",
+    "@semantic-release/github": "^12.0.0",
+    "@semantic-release/npm": "^13.0.0",
     "@types/autocannon": "^7.12.7",
     "@types/bun": "latest",
     "autocannon": "^8.0.0",
     "rxjs": "^7.8.2",
-    "semantic-release": "^25.0.0",
-    "@semantic-release/changelog": "^6.0.3",
-    "@semantic-release/git": "^10.0.1",
-    "@semantic-release/github": "^12.0.0",
-    "@semantic-release/npm": "^13.0.0"
+    "semantic-release": "^25.0.0"
   },
   "publishConfig": {
     "access": "public",

package/src/cli/index.ts

@@ -85,7 +85,20 @@ function runBuild(cmdArgs: string[]) {
   }
 
   console.log('Building Calyx application using bun build...');
-  const proc = spawnSync('bun', ['build', mainPath, '--outdir', './dist', '--target', 'bun'], { stdio: 'inherit' });
+  const proc = spawnSync('bun', [
+    'build',
+    mainPath,
+    '--outdir',
+    './dist',
+    '--target',
+    'bun',
+    '--external',
+    'mongoose',
+    '--external',
+    'typeorm',
+    '--external',
+    'graphql'
+  ], { stdio: 'inherit' });
   if (proc.status === 0) {
     console.log('Build completed successfully. Output at ./dist/main.js');
   }
@@ -108,11 +121,14 @@ function runNew(name: string) {
   mkdirSync(name, { recursive: true });
   mkdirSync(join(name, 'src'), { recursive: true });
 
-  const isDevMode = process.env.CALYX_DEV === 'true';
+  let isDevMode = process.env.CALYX_DEV === 'true';
+  const selfPkgPath = join(import.meta.dir, '../../package.json');
+  if (existsSync(selfPkgPath)) {
+    isDevMode = true; // Auto-detect workspace dev environment
+  }
   
   let packageVersion = '0.1.0';
   try {
-    const selfPkgPath = join(import.meta.dir, '../../package.json');
     if (existsSync(selfPkgPath)) {
       const selfPkg = JSON.parse(readFileSync(selfPkgPath, 'utf-8'));
       if (selfPkg.version) {

package/src/compression/compression.middleware.ts

@@ -0,0 +1,7 @@
+export function compression() {
+  return (req: any, res: any, next: any) => {
+    // Tag the response to enable compression
+    res.compressionEnabled = true;
+    next();
+  };
+}

package/src/cookies/cookies.ts

@@ -0,0 +1,69 @@
+import { createParamDecorator } from '../http/decorators.ts';
+
+export interface CookieOptions {
+  maxAge?: number;
+  expires?: Date;
+  httpOnly?: boolean;
+  secure?: boolean;
+  path?: string;
+  domain?: string;
+  sameSite?: 'lax' | 'strict' | 'none' | boolean;
+}
+
+export function parseCookies(cookieHeader: string): Record<string, string> {
+  const cookies: Record<string, string> = {};
+  if (!cookieHeader) return cookies;
+  const parts = cookieHeader.split(';');
+  for (let i = 0; i < parts.length; i++) {
+    const part = parts[i];
+    const eqIdx = part.indexOf('=');
+    if (eqIdx !== -1) {
+      const key = part.substring(0, eqIdx).trim();
+      const val = part.substring(eqIdx + 1).trim();
+      cookies[key] = decodeURIComponent(val);
+    }
+  }
+  return cookies;
+}
+
+export function formatCookie(name: string, value: string, options: CookieOptions = {}): string {
+  let str = `${name}=${encodeURIComponent(value)}`;
+  if (options.maxAge !== undefined) {
+    str += `; Max-Age=${options.maxAge}`;
+  }
+  if (options.expires !== undefined) {
+    str += `; Expires=${options.expires.toUTCString()}`;
+  }
+  if (options.path !== undefined) {
+    str += `; Path=${options.path}`;
+  } else {
+    str += `; Path=/`;
+  }
+  if (options.domain !== undefined) {
+    str += `; Domain=${options.domain}`;
+  }
+  if (options.secure) {
+    str += `; Secure`;
+  }
+  if (options.httpOnly) {
+    str += `; HttpOnly`;
+  }
+  if (options.sameSite !== undefined) {
+    if (options.sameSite === true) {
+      str += `; SameSite=Strict`;
+    } else if (options.sameSite === 'lax') {
+      str += `; SameSite=Lax`;
+    } else if (options.sameSite === 'strict') {
+      str += `; SameSite=Strict`;
+    } else if (options.sameSite === 'none') {
+      str += `; SameSite=None`;
+    }
+  }
+  return str;
+}
+
+export const Cookies = createParamDecorator((data: string | undefined, ctx) => {
+  const req = ctx.switchToHttp().getRequest();
+  const cookies = (req as any).cookies || {};
+  return data ? cookies[data] : cookies;
+});

package/src/database/mongoose.module.ts

@@ -0,0 +1,250 @@
+import { Database } from 'bun:sqlite';
+import { Module, DynamicModule, Inject } from '../core/decorators.ts';
+import { ConnectionManager } from './typeorm.module.ts';
+
+// Dynamic detection of Mongoose availability
+let isMongooseAvailable = false;
+try {
+  require.resolve('mongoose');
+  isMongooseAvailable = true;
+} catch {
+  // ignore
+}
+
+class QueryPromise<T> {
+  constructor(private readonly promise: Promise<T>) {}
+  then(onfulfilled?: any, onrejected?: any) {
+    return this.promise.then(onfulfilled, onrejected);
+  }
+  catch(onrejected?: any) {
+    return this.promise.catch(onrejected);
+  }
+  finally(onfn?: any) {
+    return this.promise.finally(onfn);
+  }
+  exec(): Promise<T> {
+    return this.promise;
+  }
+}
+
+// Native Sqlite-backed document store model fallback
+class NativeSqliteModel<T extends Record<string, any>> {
+  private tableName: string;
+
+  constructor(private readonly db: Database, private readonly modelName: string) {
+    this.tableName = `mongo_${modelName.toLowerCase()}`;
+    this.db.run(`
+      CREATE TABLE IF NOT EXISTS ${this.tableName} (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        data TEXT
+      )
+    `);
+  }
+
+  private toDoc(row: any): T | null {
+    if (!row) return null;
+    try {
+      const obj = JSON.parse(row.data);
+      obj._id = row.id;
+      return obj as T;
+    } catch {
+      return null;
+    }
+  }
+
+  async create(doc: Partial<T> | Partial<T>[]): Promise<any> {
+    const docs = Array.isArray(doc) ? doc : [doc];
+    const created: T[] = [];
+    for (const d of docs) {
+      const dataCopy = { ...d };
+      delete dataCopy._id;
+      const jsonStr = JSON.stringify(dataCopy);
+      const result = this.db.query(`INSERT INTO ${this.tableName} (data) VALUES ($data) RETURNING id`).get({
+        $data: jsonStr,
+      }) as any;
+      created.push({ ...d, _id: result.id } as unknown as T);
+    }
+    return Array.isArray(doc) ? created : created[0];
+  }
+
+  async find(conditions: Partial<T> = {}): Promise<T[]> {
+    if (Object.keys(conditions).length === 0) {
+      const rows = this.db.query(`SELECT id, data FROM ${this.tableName}`).all() as any[];
+      return rows.map((r) => this.toDoc(r)).filter(Boolean) as T[];
+    }
+
+    const conds: string[] = [];
+    const params: Record<string, any> = {};
+
+    for (const [key, val] of Object.entries(conditions)) {
+      if (key === '_id') {
+        conds.push(`id = $id`);
+        params['$id'] = val;
+      } else {
+        conds.push(`json_extract(data, '$.${key}') = $${key}`);
+        params[`$${key}`] = val;
+      }
+    }
+
+    const sql = `SELECT id, data FROM ${this.tableName} WHERE ${conds.join(' AND ')}`;
+    const rows = this.db.query(sql).all(params) as any[];
+    return rows.map((r) => this.toDoc(r)).filter(Boolean) as T[];
+  }
+
+  async findOne(conditions: Partial<T> = {}): Promise<T | null> {
+    const list = await this.find(conditions);
+    return list.length > 0 ? list[0] : null;
+  }
+
+  async updateOne(conditions: Partial<T>, update: Partial<T>): Promise<any> {
+    const doc = await this.findOne(conditions);
+    if (!doc) return { matchedCount: 0, modifiedCount: 0 };
+
+    const updatedData = { ...doc, ...update };
+    const id = doc._id;
+    delete updatedData._id;
+
+    this.db.query(`UPDATE ${this.tableName} SET data = $data WHERE id = $id`).run({
+      $data: JSON.stringify(updatedData),
+      $id: id,
+    });
+
+    return { matchedCount: 1, modifiedCount: 1 };
+  }
+
+  async deleteOne(conditions: Partial<T>): Promise<any> {
+    const doc = await this.findOne(conditions);
+    if (!doc) return { deletedCount: 0 };
+
+    this.db.query(`DELETE FROM ${this.tableName} WHERE id = $id`).run({ $id: doc._id });
+    return { deletedCount: 1 };
+  }
+}
+
+// Unified Mongoose Model wrapper
+export class Model<T extends Record<string, any>> {
+  private modelPromise: Promise<any>;
+
+  constructor(
+    connOrDbPromise: Promise<any>,
+    private readonly modelName: string,
+    private readonly schema: any,
+    private readonly isNative: boolean
+  ) {
+    if (isNative) {
+      this.modelPromise = connOrDbPromise.then((db) => new NativeSqliteModel(db, modelName));
+    } else {
+      this.modelPromise = connOrDbPromise.then((conn) => {
+        // Compile schema/model using real mongoose connection
+        return conn.models[modelName] || conn.model(modelName, schema || {});
+      });
+    }
+  }
+
+  create(doc: Partial<T> | Partial<T>[]): QueryPromise<any> {
+    const promise = this.modelPromise.then((model) => model.create(doc));
+    return new QueryPromise(promise);
+  }
+
+  find(conditions: Partial<T> = {}): QueryPromise<T[]> {
+    const promise = this.modelPromise.then(async (model) => {
+      const q = model.find(conditions);
+      return typeof q.exec === 'function' ? await q.exec() : await q;
+    });
+    return new QueryPromise(promise);
+  }
+
+  findOne(conditions: Partial<T> = {}): QueryPromise<T | null> {
+    const promise = this.modelPromise.then(async (model) => {
+      const q = model.findOne(conditions);
+      return typeof q.exec === 'function' ? await q.exec() : await q;
+    });
+    return new QueryPromise(promise);
+  }
+
+  updateOne(conditions: Partial<T>, update: Partial<T>): QueryPromise<any> {
+    const promise = this.modelPromise.then(async (model) => {
+      const q = model.updateOne(conditions, update);
+      return typeof q.exec === 'function' ? await q.exec() : await q;
+    });
+    return new QueryPromise(promise);
+  }
+
+  deleteOne(conditions: Partial<T>): QueryPromise<any> {
+    const promise = this.modelPromise.then(async (model) => {
+      const q = model.deleteOne(conditions);
+      return typeof q.exec === 'function' ? await q.exec() : await q;
+    });
+    return new QueryPromise(promise);
+  }
+}
+
+export function InjectModel(name: string): ParameterDecorator & PropertyDecorator {
+  return Inject(`Model_${name}`);
+}
+
+@Module({})
+export class MongooseModule {
+  static forRoot(uri: string, options: any = {}): DynamicModule {
+    const isUsingMongoose = isMongooseAvailable && !options.useNativeFallback;
+
+    let connOrDbPromise: Promise<any>;
+    if (isUsingMongoose) {
+      connOrDbPromise = (async () => {
+        const mongoose = await import('mongoose');
+        const conn = mongoose.createConnection(uri, options);
+        // Wait for connection to open
+        await new Promise((resolve, reject) => {
+          conn.once('open', resolve);
+          conn.once('error', reject);
+        });
+        return conn;
+      })();
+    } else {
+      let dbPath = ':memory:';
+      if (uri.startsWith('mongodb://') || uri.startsWith('mongodb+srv://')) {
+        const match = uri.match(/\/([a-zA-Z0-9_-]+)(?:\?|$)/);
+        if (match && match[1]) {
+          dbPath = `${match[1]}.db`;
+        }
+      }
+      connOrDbPromise = Promise.resolve(ConnectionManager.getOrCreate(dbPath));
+    }
+
+    return {
+      module: MongooseModule,
+      providers: [
+        {
+          provide: 'Calyx_Mongo_Connection',
+          useValue: connOrDbPromise,
+        },
+        {
+          provide: 'Calyx_Mongo_IsNative',
+          useValue: !isUsingMongoose,
+        },
+      ],
+      exports: ['Calyx_Mongo_Connection', 'Calyx_Mongo_IsNative'],
+      global: true,
+    };
+  }
+
+  static forFeature(models: { name: string; schema?: any }[] = []): DynamicModule {
+    const providers = models.map((m) => {
+      return {
+        provide: `Model_${m.name}`,
+        useFactory: (connOrDbPromise: Promise<any>, isNative: boolean) => {
+          const resolvedPromise = connOrDbPromise ?? Promise.resolve(ConnectionManager.getOrCreate());
+          const resolvedIsNative = isNative !== undefined ? isNative : true;
+          return new Model(resolvedPromise, m.name, m.schema, resolvedIsNative);
+        },
+        inject: ['Calyx_Mongo_Connection', 'Calyx_Mongo_IsNative'],
+      };
+    });
+
+    return {
+      module: MongooseModule,
+      providers,
+      exports: models.map((m) => `Model_${m.name}`),
+    };
+  }
+}

package/src/database/typeorm.module.ts

@@ -0,0 +1,276 @@
+import { Database } from 'bun:sqlite';
+import { Module, DynamicModule, Inject } from '../core/decorators.ts';
+
+// Dynamic detection of TypeORM availability
+let isTypeormAvailable = false;
+try {
+  // We check if typeorm package is in path
+  require.resolve('typeorm');
+  isTypeormAvailable = true;
+} catch {
+  // ignore
+}
+
+// Connection manager for Native SQLite fallback
+export class ConnectionManager {
+  private static db: Database | null = null;
+
+  static getOrCreate(databasePath = ':memory:'): Database {
+    if (!this.db) {
+      this.db = new Database(databasePath);
+    }
+    return this.db;
+  }
+
+  static close() {
+    if (this.db) {
+      this.db.close();
+      this.db = null;
+    }
+  }
+}
+
+// Native Sqlite Repository fallback
+class NativeSqliteRepository<Entity extends Record<string, any>> {
+  private tableName: string;
+
+  constructor(private readonly db: Database, private readonly entityClass: any) {
+    this.tableName = entityClass.name.toLowerCase();
+    this.db.run(`
+      CREATE TABLE IF NOT EXISTS ${this.tableName} (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        data TEXT
+      )
+    `);
+  }
+
+  private toEntity(row: any): Entity | null {
+    if (!row) return null;
+    try {
+      const obj = JSON.parse(row.data);
+      obj.id = row.id;
+      const instance = Object.create(this.entityClass.prototype);
+      Object.assign(instance, obj);
+      return instance;
+    } catch {
+      return null;
+    }
+  }
+
+  async save(entity: Entity | Entity[]): Promise<any> {
+    const entities = Array.isArray(entity) ? entity : [entity];
+    const saved: Entity[] = [];
+
+    for (const ent of entities) {
+      const dataCopy = { ...ent };
+      const id = dataCopy.id;
+      delete dataCopy.id;
+
+      const jsonStr = JSON.stringify(dataCopy);
+
+      if (id !== undefined && id !== null) {
+        this.db.query(`UPDATE ${this.tableName} SET data = $data WHERE id = $id`).run({
+          $data: jsonStr,
+          $id: id,
+        });
+        saved.push(ent);
+      } else {
+        const result = this.db.query(`INSERT INTO ${this.tableName} (data) VALUES ($data) RETURNING id`).get({
+          $data: jsonStr,
+        }) as any;
+        const newEntity = Object.create(this.entityClass.prototype);
+        Object.assign(newEntity, ent, { id: result.id });
+        saved.push(newEntity);
+      }
+    }
+
+    return Array.isArray(entity) ? saved : saved[0];
+  }
+
+  async find(options?: { where?: Partial<Entity> }): Promise<Entity[]> {
+    const where = options?.where;
+    if (!where || Object.keys(where).length === 0) {
+      const rows = this.db.query(`SELECT id, data FROM ${this.tableName}`).all() as any[];
+      return rows.map((r) => this.toEntity(r)).filter(Boolean) as Entity[];
+    }
+
+    const conditions: string[] = [];
+    const params: Record<string, any> = {};
+
+    for (const [key, val] of Object.entries(where)) {
+      if (key === 'id') {
+        conditions.push(`id = $id`);
+        params['$id'] = val;
+      } else {
+        conditions.push(`json_extract(data, '$.${key}') = $${key}`);
+        params[`$${key}`] = typeof val === 'object' ? JSON.stringify(val) : val;
+      }
+    }
+
+    const sql = `SELECT id, data FROM ${this.tableName} WHERE ${conditions.join(' AND ')}`;
+    const rows = this.db.query(sql).all(params) as any[];
+    return rows.map((r) => this.toEntity(r)).filter(Boolean) as Entity[];
+  }
+
+  async findOne(options: { where: Partial<Entity> }): Promise<Entity | null> {
+    const results = await this.find(options);
+    return results.length > 0 ? results[0] : null;
+  }
+
+  async delete(conditions: Partial<Entity> | number | string): Promise<any> {
+    if (typeof conditions === 'number' || typeof conditions === 'string') {
+      this.db.query(`DELETE FROM ${this.tableName} WHERE id = $id`).run({ $id: Number(conditions) });
+      return { affected: 1 };
+    }
+
+    const where = conditions as Record<string, any>;
+    if (Object.keys(where).length === 0) {
+      this.db.run(`DELETE FROM ${this.tableName}`);
+      return { affected: null };
+    }
+
+    const conds: string[] = [];
+    const params: Record<string, any> = {};
+
+    for (const [key, val] of Object.entries(where)) {
+      if (key === 'id') {
+        conds.push(`id = $id`);
+        params['$id'] = val;
+      } else {
+        conds.push(`json_extract(data, '$.${key}') = $${key}`);
+        params[`$${key}`] = val;
+      }
+    }
+
+    const sql = `DELETE FROM ${this.tableName} WHERE ${conds.join(' AND ')}`;
+    this.db.query(sql).run(params);
+    return { affected: null };
+  }
+
+  async update(conditions: Partial<Entity> | number | string, value: Partial<Entity>): Promise<any> {
+    const id = typeof conditions === 'number' || typeof conditions === 'string' ? Number(conditions) : conditions.id;
+
+    if (id !== undefined) {
+      const existing = await this.findOne({ where: { id } as any });
+      if (existing) {
+        const updatedData = { ...existing, ...value };
+        await this.save(updatedData);
+      }
+      return { affected: 1 };
+    }
+
+    const matches = await this.find({ where: conditions as Partial<Entity> });
+    for (const match of matches) {
+      const updatedData = { ...match, ...value };
+      await this.save(updatedData);
+    }
+    return { affected: matches.length };
+  }
+}
+
+// Unified Repository Wrapper
+export class Repository<Entity extends Record<string, any>> {
+  private repoPromise: Promise<any>;
+
+  constructor(dbOrDs: any, private readonly entityClass: any, private readonly isNative?: boolean) {
+    const promise = dbOrDs instanceof Promise ? dbOrDs : Promise.resolve(dbOrDs);
+    const native = isNative ?? true;
+    if (native) {
+      this.repoPromise = promise.then((db) => new NativeSqliteRepository(db, entityClass));
+    } else {
+      this.repoPromise = promise.then((ds) => ds.getRepository(entityClass));
+    }
+  }
+
+  async save(entity: Entity | Entity[]): Promise<any> {
+    const repo = await this.repoPromise;
+    return await repo.save(entity);
+  }
+
+  async find(options?: any): Promise<Entity[]> {
+    const repo = await this.repoPromise;
+    return await repo.find(options);
+  }
+
+  async findOne(options: any): Promise<Entity | null> {
+    const repo = await this.repoPromise;
+    return await repo.findOne(options);
+  }
+
+  async delete(conditions: any): Promise<any> {
+    const repo = await this.repoPromise;
+    return await repo.delete(conditions);
+  }
+
+  async update(conditions: any, value: any): Promise<any> {
+    const repo = await this.repoPromise;
+    return await repo.update(conditions, value);
+  }
+}
+
+export function InjectRepository(entity: any): ParameterDecorator & PropertyDecorator {
+  return Inject(`Repository_${entity.name}`);
+}
+
+export interface TypeOrmModuleOptions {
+  type?: string;
+  database?: string;
+  entities?: any[];
+  synchronize?: boolean;
+  [key: string]: any;
+}
+
+@Module({})
+export class TypeOrmModule {
+  static forRoot(options: TypeOrmModuleOptions = {}): DynamicModule {
+    const isUsingTypeorm = isTypeormAvailable && options.type !== 'sqlite-native';
+
+    let dbOrDsPromise: Promise<any>;
+    if (isUsingTypeorm) {
+      dbOrDsPromise = (async () => {
+        const { DataSource } = await import('typeorm');
+        const ds = new DataSource(options as any);
+        await ds.initialize();
+        return ds;
+      })();
+    } else {
+      dbOrDsPromise = Promise.resolve(ConnectionManager.getOrCreate(options.database));
+    }
+
+    return {
+      module: TypeOrmModule,
+      providers: [
+        {
+          provide: 'Calyx_Database_Connection',
+          useValue: dbOrDsPromise,
+        },
+        {
+          provide: 'Calyx_Database_IsNative',
+          useValue: !isUsingTypeorm,
+        },
+      ],
+      exports: ['Calyx_Database_Connection', 'Calyx_Database_IsNative'],
+      global: true,
+    };
+  }
+
+  static forFeature(entities: any[] = []): DynamicModule {
+    const providers = entities.map((entity) => {
+      return {
+        provide: `Repository_${entity.name}`,
+        useFactory: (dbOrDsPromise: Promise<any>, isNative: boolean) => {
+          const resolvedPromise = dbOrDsPromise ?? Promise.resolve(ConnectionManager.getOrCreate());
+          const resolvedIsNative = isNative !== undefined ? isNative : true;
+          return new Repository(resolvedPromise, entity, resolvedIsNative);
+        },
+        inject: ['Calyx_Database_Connection', 'Calyx_Database_IsNative'],
+      };
+    });
+
+    return {
+      module: TypeOrmModule,
+      providers,
+      exports: entities.map((entity) => `Repository_${entity.name}`),
+    };
+  }
+}