@martel/calyx 1.7.0 → 1.9.0

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}`),
+    };
+  }
+}

package/src/file-upload/file-upload.interceptor.ts

@@ -0,0 +1,93 @@
+import { NestInterceptor, ExecutionContext, CallHandler } from '../lifecycle/interfaces.ts';
+import { createParamDecorator } from '../http/decorators.ts';
+import { Injectable } from '../core/decorators.ts';
+
+export interface MulterFile {
+  fieldname: string;
+  originalname: string;
+  encoding: string;
+  mimetype: string;
+  size: number;
+  buffer: Buffer;
+}
+
+@Injectable()
+export class FileInterceptor implements NestInterceptor {
+  constructor(private readonly fieldName: string) {}
+
+  async intercept(context: ExecutionContext, next: CallHandler) {
+    const ctx = context.switchToHttp();
+    const req = ctx.getRequest();
+    const contentType = req.headers.get('content-type') || '';
+
+    if (contentType.includes('multipart/form-data')) {
+      try {
+        const formData = await req.clone().formData();
+        const file = formData.get(this.fieldName);
+        if (file && typeof file !== 'string') {
+          const buffer = Buffer.from(await file.arrayBuffer());
+          (req as any).file = {
+            fieldname: this.fieldName,
+            originalname: file.name,
+            encoding: '7bit',
+            mimetype: file.type,
+            size: file.size,
+            buffer,
+          };
+        }
+      } catch (err) {
+        console.error('FileInterceptor parsing error:', err);
+      }
+    }
+
+    return next.handle();
+  }
+}
+
+@Injectable()
+export class FilesInterceptor implements NestInterceptor {
+  constructor(private readonly fieldName: string) {}
+
+  async intercept(context: ExecutionContext, next: CallHandler) {
+    const ctx = context.switchToHttp();
+    const req = ctx.getRequest();
+    const contentType = req.headers.get('content-type') || '';
+
+    if (contentType.includes('multipart/form-data')) {
+      try {
+        const formData = await req.clone().formData();
+        const files = formData.getAll(this.fieldName);
+        const multerFiles: MulterFile[] = [];
+
+        for (const file of files) {
+          if (file && typeof file !== 'string') {
+            const buffer = Buffer.from(await file.arrayBuffer());
+            multerFiles.push({
+              fieldname: this.fieldName,
+              originalname: file.name,
+              encoding: '7bit',
+              mimetype: file.type,
+              size: file.size,
+              buffer,
+            });
+          }
+        }
+        (req as any).files = multerFiles;
+      } catch {
+        // ignore
+      }
+    }
+
+    return next.handle();
+  }
+}
+
+export const UploadedFile = createParamDecorator((data, ctx) => {
+  const req = ctx.switchToHttp().getRequest();
+  return (req as any).file;
+});
+
+export const UploadedFiles = createParamDecorator((data, ctx) => {
+  const req = ctx.switchToHttp().getRequest();
+  return (req as any).files;
+});

package/src/file-upload/index.ts

@@ -0,0 +1 @@
+export * from './file-upload.interceptor.ts';

package/src/graphql/decorators.ts

@@ -0,0 +1,132 @@
+import { METADATA_KEYS } from '../core/metadata.ts';
+
+export function Resolver(nameOrClass?: any): ClassDecorator {
+  return (target) => {
+    Reflect.defineMetadata('calyx:resolver', nameOrClass || target, target);
+    Reflect.defineMetadata(METADATA_KEYS.INJECTABLE, true, target);
+  };
+}
+
+export function Query(typeFunc?: (returns: any) => any, options?: { name?: string }): MethodDecorator {
+  return (target, propertyKey) => {
+    const queries = Reflect.getOwnMetadata('calyx:queries', target.constructor) || [];
+    queries.push({ propertyKey, typeFunc, options });
+    Reflect.defineMetadata('calyx:queries', queries, target.constructor);
+  };
+}
+
+export function Mutation(typeFunc?: (returns: any) => any, options?: { name?: string }): MethodDecorator {
+  return (target, propertyKey) => {
+    const mutations = Reflect.getOwnMetadata('calyx:mutations', target.constructor) || [];
+    mutations.push({ propertyKey, typeFunc, options });
+    Reflect.defineMetadata('calyx:mutations', mutations, target.constructor);
+  };
+}
+
+export function ResolveField(typeFunc?: (returns: any) => any, options?: { name?: string }): MethodDecorator {
+  return (target, propertyKey) => {
+    const fields = Reflect.getOwnMetadata('calyx:resolve_fields', target.constructor) || [];
+    fields.push({ propertyKey, typeFunc, options });
+    Reflect.defineMetadata('calyx:resolve_fields', fields, target.constructor);
+  };
+}
+
+export function Args(name?: string): ParameterDecorator {
+  return (target, propertyKey, parameterIndex) => {
+    const args = Reflect.getOwnMetadata('calyx:args', target, propertyKey!) || [];
+    args.push({ parameterIndex, name });
+    Reflect.defineMetadata('calyx:args', args, target, propertyKey!);
+  };
+}
+
+export function Parent(): ParameterDecorator {
+  return (target, propertyKey, parameterIndex) => {
+    const parentParams = Reflect.getOwnMetadata('calyx:parent', target, propertyKey!) || [];
+    parentParams.push(parameterIndex);
+    Reflect.defineMetadata('calyx:parent', parentParams, target, propertyKey!);
+  };
+}
+
+export function ObjectType(): ClassDecorator {
+  return (target) => {
+    Reflect.defineMetadata('calyx:object_type', true, target);
+  };
+}
+
+export function Field(typeFunc?: (returns: any) => any, options?: { nullable?: boolean }): PropertyDecorator {
+  return (target, propertyKey) => {
+    const fields = Reflect.getOwnMetadata('calyx:fields', target.constructor) || [];
+    fields.push({ propertyKey: String(propertyKey), typeFunc, options });
+    Reflect.defineMetadata('calyx:fields', fields, target.constructor);
+  };
+}
+
+export function InputType(options?: { description?: string }): ClassDecorator {
+  return (target) => {
+    Reflect.defineMetadata('calyx:input_type', true, target);
+    if (options?.description) {
+      Reflect.defineMetadata('calyx:description', options.description, target);
+    }
+  };
+}
+
+export function ArgsType(): ClassDecorator {
+  return (target) => {
+    Reflect.defineMetadata('calyx:args_type', true, target);
+  };
+}
+
+export function InterfaceType(options?: { description?: string }): ClassDecorator {
+  return (target) => {
+    Reflect.defineMetadata('calyx:interface_type', true, target);
+    if (options?.description) {
+      Reflect.defineMetadata('calyx:description', options.description, target);
+    }
+  };
+}
+
+export function UnionType(options: { name: string; types: () => any[] }): ClassDecorator {
+  return (target) => {
+    Reflect.defineMetadata('calyx:union_type', options, target);
+  };
+}
+
+export function createUnionType(options: { name: string; types: () => any[]; resolveType?: any }) {
+  return {
+    name: options.name,
+    types: options.types,
+    resolveType: options.resolveType,
+    __isUnion: true,
+  };
+}
+
+export function Subscription(typeFunc?: (returns: any) => any, options?: { name?: string; filter?: any; resolve?: any }): MethodDecorator {
+  return (target, propertyKey) => {
+    const subscriptions = Reflect.getOwnMetadata('calyx:subscriptions', target.constructor) || [];
+    subscriptions.push({ propertyKey, typeFunc, options });
+    Reflect.defineMetadata('calyx:subscriptions', subscriptions, target.constructor);
+  };
+}
+
+export function Scalar(name: string, typeFunc?: any): ClassDecorator {
+  return (target) => {
+    Reflect.defineMetadata('calyx:scalar', { name, typeFunc }, target);
+    Reflect.defineMetadata(METADATA_KEYS.INJECTABLE, true, target);
+  };
+}
+
+export function Directive(sdl: string): ClassDecorator & MethodDecorator & PropertyDecorator {
+  return (target: any, propertyKey?: string | symbol) => {
+    const key = 'calyx:directives';
+    if (propertyKey) {
+      const existing = Reflect.getOwnMetadata(key, target, propertyKey) || [];
+      existing.push(sdl);
+      Reflect.defineMetadata(key, existing, target, propertyKey);
+    } else {
+      const existing = Reflect.getOwnMetadata(key, target) || [];
+      existing.push(sdl);
+      Reflect.defineMetadata(key, existing, target);
+    }
+  };
+}
+