@rx-ted/packages-honest-plugins 1.0.1

package/db/src/repository.test.ts

@@ -0,0 +1,195 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { BaseRepository } from './repository';
+import type { Table } from 'drizzle-orm';
+
+function createMockDb() {
+  const results: any[] = [];
+
+  const qb: any = {
+    from: vi.fn().mockReturnThis(),
+    where: vi.fn().mockReturnThis(),
+    limit: vi.fn().mockReturnThis(),
+    offset: vi.fn().mockReturnThis(),
+    orderBy: vi.fn().mockReturnThis(),
+  };
+  qb.then = (resolve: (v: any) => void) => {
+    const val = results.shift() ?? [];
+    resolve(val);
+    return Promise.resolve(val);
+  };
+
+  const db = {
+    select: vi.fn().mockReturnValue(qb),
+    insert: vi.fn().mockReturnValue({
+      values: vi.fn().mockResolvedValue([{ insertId: 1 }]),
+    }),
+    update: vi.fn().mockReturnValue({
+      set: vi.fn().mockReturnValue({
+        where: vi.fn().mockResolvedValue([{ affectedRows: 1 }]),
+      }),
+    }),
+    delete: vi.fn().mockReturnValue({
+      where: vi.fn().mockResolvedValue({ affectedRows: 1 }),
+    }),
+  };
+
+  return {
+    db,
+    qb,
+    addResult: (val: any) => {
+      results.push(val);
+    },
+  };
+}
+
+const mockTable = { _: { name: 'users' } } as unknown as Table;
+
+describe('BaseRepository', () => {
+  let repo: BaseRepository<typeof mockTable>;
+  let db: ReturnType<typeof createMockDb>['db'];
+  let qb: ReturnType<typeof createMockDb>['qb'];
+  let addResult: ReturnType<typeof createMockDb>['addResult'];
+
+  beforeEach(() => {
+    const mocks = createMockDb();
+    db = mocks.db;
+    qb = mocks.qb;
+    addResult = mocks.addResult;
+    repo = new BaseRepository(mocks.db, mockTable);
+  });
+
+  describe('findById', () => {
+    it('returns the row when found', async () => {
+      addResult([{ id: '1', name: 'Alice' }]);
+
+      const result = await repo.findById('1');
+
+      expect(result).toEqual({ id: '1', name: 'Alice' });
+      expect(db.select).toHaveBeenCalled();
+      expect(qb.from).toHaveBeenCalledWith(mockTable);
+    });
+
+    it('returns null when not found', async () => {
+      addResult([]);
+
+      const result = await repo.findById('1');
+
+      expect(result).toBeNull();
+    });
+  });
+
+  describe('findMany', () => {
+    it('returns all rows without options', async () => {
+      addResult([{ id: '1' }, { id: '2' }]);
+
+      const result = await repo.findMany();
+
+      expect(result).toEqual([{ id: '1' }, { id: '2' }]);
+    });
+
+    it('filters with where clause', async () => {
+      addResult([{ id: '1', role: 'admin' }]);
+
+      const result = await repo.findMany({ where: { role: 'admin' } });
+
+      expect(result).toHaveLength(1);
+      expect(qb.where).toHaveBeenCalled();
+    });
+
+    it('applies ordering', async () => {
+      addResult([{ id: '2' }, { id: '1' }]);
+
+      await repo.findMany({ orderBy: { createdAt: 'desc' } });
+
+      expect(qb.orderBy).toHaveBeenCalled();
+    });
+
+    it('applies pagination', async () => {
+      addResult([{ id: '1' }]);
+
+      await repo.findMany({ pagination: { page: 2, pageSize: 10 } });
+
+      expect(qb.limit).toHaveBeenCalledWith(10);
+      expect(qb.offset).toHaveBeenCalledWith(10);
+    });
+  });
+
+  describe('create', () => {
+    it('inserts data and returns result', async () => {
+      const result = await repo.create({ name: 'Bob' });
+
+      expect(result).toEqual({ insertId: 1, affectedRows: 0 });
+      expect(db.insert().values).toHaveBeenCalledWith({ name: 'Bob' });
+    });
+  });
+
+  describe('update', () => {
+    it('updates and returns result', async () => {
+      const result = await repo.update('1', { name: 'Bob' });
+
+      expect(result).toEqual({ affectedRows: 1 });
+    });
+  });
+
+  describe('delete', () => {
+    it('returns true when rows affected', async () => {
+      const result = await repo.delete('1');
+
+      expect(result).toBe(true);
+    });
+
+    it('returns false when no rows affected', async () => {
+      (db.delete().where as any).mockResolvedValue({ affectedRows: 0 });
+
+      const result = await repo.delete('1');
+
+      expect(result).toBe(false);
+    });
+  });
+
+  describe('count', () => {
+    it('returns count without where', async () => {
+      addResult([{ count: 5 }]);
+
+      const result = await repo.count();
+
+      expect(result).toBe(5);
+    });
+
+    it('returns 0 when no rows', async () => {
+      addResult([{ count: null }]);
+
+      const result = await repo.count();
+
+      expect(result).toBe(0);
+    });
+
+    it('filters with where clause', async () => {
+      addResult([{ count: 3 }]);
+
+      const result = await repo.count({ role: 'admin' });
+
+      expect(result).toBe(3);
+      expect(qb.where).toHaveBeenCalled();
+    });
+  });
+
+  describe('findWithPagination', () => {
+    it('returns paginated result with defaults', async () => {
+      addResult([{ id: '1' }, { id: '2' }]); // findMany
+      addResult([{ count: 20 }]); // count
+
+      const result = await repo.findWithPagination({
+        pagination: { page: 1, pageSize: 2 },
+      });
+
+      expect(result).toEqual({
+        data: [{ id: '1' }, { id: '2' }],
+        total: 20,
+        page: 1,
+        pageSize: 2,
+        totalPages: 10,
+      });
+    });
+  });
+});

package/db/src/repository.ts

@@ -0,0 +1,95 @@
+import { type Table, eq, and } from 'drizzle-orm';
+import { sql } from 'drizzle-orm';
+import type { QueryOptions, PaginationResult } from './types';
+
+export class BaseRepository<TTable extends Table> {
+  protected db: any;
+  protected table: TTable;
+
+  constructor(db: any, table: TTable) {
+    this.db = db;
+    this.table = table;
+  }
+
+  async findById(id: string): Promise<any | null> {
+    const [result] = await this.db
+      .select()
+      .from(this.table)
+      .where(eq((this.table as any).id, id))
+      .limit(1);
+    return result ?? null;
+  }
+
+  async findMany(options?: QueryOptions): Promise<any[]> {
+    let query = this.db.select().from(this.table);
+    if (options?.where) {
+      const conditions = Object.entries(options.where).map(([key, value]) =>
+        eq((this.table as any)[key], value),
+      );
+      query = query.where(and(...conditions));
+    }
+    if (options?.orderBy) {
+      for (const [key, dir] of Object.entries(options.orderBy)) {
+        query = query.orderBy(
+          dir === 'desc'
+            ? sql`${(this.table as any)[key]} desc`
+            : sql`${(this.table as any)[key]} asc`,
+        );
+      }
+    }
+    if (options?.pagination) {
+      const { page, pageSize } = options.pagination;
+      query = query.limit(pageSize).offset((page - 1) * pageSize);
+    }
+    return query;
+  }
+
+  async findWithPagination(options?: QueryOptions): Promise<PaginationResult<any>> {
+    const page = options?.pagination?.page ?? 1;
+    const pageSize = options?.pagination?.pageSize ?? 10;
+    const data = await this.findMany(options);
+    const total = await this.count(options?.where);
+    return {
+      data,
+      total,
+      page,
+      pageSize,
+      totalPages: Math.ceil(total / pageSize),
+    };
+  }
+
+  async create(data: any): Promise<any> {
+    const raw: any = await this.db.insert(this.table).values(data);
+    const r = Array.isArray(raw) ? raw[0] : raw;
+    return {
+      insertId: Number(r.insertId ?? r.lastInsertRowid ?? r.meta?.last_row_id),
+      affectedRows: Number(r.affectedRows ?? r.rowsAffected ?? r.meta?.changes ?? 0),
+    };
+  }
+
+  async update(id: string, data: any): Promise<any | null> {
+    const raw: any = await this.db
+      .update(this.table)
+      .set(data)
+      .where(eq((this.table as any).id, id));
+    const r = Array.isArray(raw) ? raw[0] : raw;
+    return r ?? null;
+  }
+
+  async delete(id: string): Promise<boolean> {
+    const result = await this.db.delete(this.table).where(eq((this.table as any).id, id));
+    return result.affectedRows > 0;
+  }
+
+  async count(where?: Record<string, any>): Promise<number> {
+    let query = this.db.select({ count: sql<number>`count(*)` }).from(this.table);
+    if (where) {
+      const conditions = Object.entries(where).map(([key, value]) =>
+        eq((this.table as any)[key], value),
+      );
+      query = query.where(and(...conditions));
+    }
+    const [result] = await query;
+    return Number(result?.count ?? 0);
+  }
+}

package/db/src/resolve.ts

@@ -0,0 +1,105 @@
+import { ENV_SYMBOL, Env } from '@rx-ted/packages-core';
+import { ComponentManager } from '@rx-ted/packages-honest';
+import type { IPlugin } from '@rx-ted/packages-honest';
+
+export type AppRuntime = 'node' | 'bun' | 'deno' | 'cloudflare' | 'vercel-edge';
+export type DbType = 'd1' | 'sqlite' | 'mysql';
+
+const RUNTIME_DB_MAP: Record<AppRuntime, DbType[]> = {
+  cloudflare: ['d1'],
+  node: ['sqlite', 'mysql'],
+  bun: ['sqlite', 'mysql'],
+  deno: ['sqlite', 'mysql'],
+  'vercel-edge': [],
+};
+
+const PLUGIN_DB_TYPE: Record<string, DbType> = {
+  D1Plugin: 'd1',
+  SqlitePlugin: 'sqlite',
+  MysqlPlugin: 'mysql',
+};
+
+function getAppEnv(): Env {
+  if (ComponentManager.hasPlugin(ENV_SYMBOL)) {
+    return ComponentManager.getPlugin<Env>(ENV_SYMBOL);
+  }
+  return new Env(process.env, {});
+}
+
+export function assertRuntimeSupport(runtime: AppRuntime, dbType: DbType): void {
+  if (!(runtime in RUNTIME_DB_MAP)) {
+    throw new Error(
+      `[db] Unsupported runtime "${runtime}". ` +
+        `Supported: ${Object.keys(RUNTIME_DB_MAP).join(', ')}. ` +
+        `Contact the developer to add support for this runtime.`,
+    );
+  }
+  const allowed = RUNTIME_DB_MAP[runtime];
+  if (!allowed.includes(dbType)) {
+    throw new Error(
+      `[db] Database "${dbType}" is not supported on runtime "${runtime}". ` +
+        `Allowed databases for "${runtime}": ${allowed.join(', ')}. ` +
+        `Change the DB env var or switch to a different runtime.`,
+    );
+  }
+}
+
+function dbTypeFromPlugin(plugin: IPlugin): DbType {
+  const name = plugin.constructor?.name;
+  const dbType = name ? PLUGIN_DB_TYPE[name] : undefined;
+  if (!dbType) {
+    throw new Error(
+      `[db] Unknown plugin "${name}". ` +
+        `Supported plugins: ${Object.keys(PLUGIN_DB_TYPE).join(', ')}.`,
+    );
+  }
+  return dbType;
+}
+
+export async function DBPlugin(schema: Record<string, any>): Promise<IPlugin>;
+export async function DBPlugin(plugin: IPlugin): Promise<IPlugin>;
+export async function DBPlugin(arg: any): Promise<IPlugin> {
+  const appEnv = getAppEnv();
+
+  // Explicit mode: user passed a pre-created plugin
+  if (arg && typeof arg === 'object' && 'name' in arg && 'version' in arg) {
+    const dbType = dbTypeFromPlugin(arg as IPlugin);
+    assertRuntimeSupport(appEnv.platform as AppRuntime, dbType);
+    return arg as IPlugin;
+  }
+
+  // Auto-detect mode: arg is schema
+  const runtime = appEnv.platform as AppRuntime;
+  const dbRaw = appEnv.get('DB');
+  const db: DbType =
+    (typeof dbRaw === 'string' ? (dbRaw as DbType) : undefined) ??
+    RUNTIME_DB_MAP[runtime]?.[0] ??
+    'sqlite';
+  assertRuntimeSupport(runtime, db);
+
+  if (db === 'd1') {
+    const { D1Plugin } = await import('./d1/plugin');
+    return new D1Plugin({ schema: arg });
+  }
+
+  if (db === 'sqlite') {
+    const { SqlitePlugin } = await import('./sqlite/plugin');
+    return new SqlitePlugin({
+      dbPath: appEnv.var('DB_PATH', 'data/app.db'),
+      schema: arg,
+    });
+  }
+
+  const { MysqlPlugin } = await import('./mysql/plugin');
+  return new MysqlPlugin({
+    connection: {
+      host: appEnv.get('DB_HOST', 'string'),
+      port: appEnv.get('DB_PORT', 'number'),
+      user: appEnv.get('DB_USER', 'string'),
+      password: appEnv.get('DB_PASSWORD') ?? '',
+      database: appEnv.get('DB_DATABASE', 'string'),
+    },
+    schema: arg,
+    logger: true,
+  });
+}

package/db/src/schema-builder/column-builder.test.ts

@@ -0,0 +1,55 @@
+import { describe, it, expect } from 'vitest';
+import { ColumnBuilder } from './column-builder';
+
+describe('ColumnBuilder', () => {
+  it('builds varchar definition', () => {
+    const col = new ColumnBuilder('varchar', { length: 255 });
+    const def = col.build('email');
+    expect(def).toMatchObject({ type: 'varchar', name: 'email', length: 255 });
+  });
+
+  it('supports chainable modifiers', () => {
+    const def = new ColumnBuilder('bigint')
+      .primaryKey()
+      .autoIncrement()
+      .notNull()
+      .unique()
+      .build('id');
+    expect(def.primaryKey).toBe(true);
+    expect(def.autoIncrement).toBe(true);
+    expect(def.notNull).toBe(true);
+    expect(def.unique).toBe(true);
+  });
+
+  it('supports default value', () => {
+    const def = new ColumnBuilder('varchar', { length: 20 }).default('user').build('role');
+    expect(def.default).toBe('user');
+  });
+
+  it('supports enum values', () => {
+    const def = new ColumnBuilder('enum', { values: ['admin', 'user'] }).build('role');
+    expect(def.values).toEqual(['admin', 'user']);
+  });
+
+  it('supports references', () => {
+    const target = new ColumnBuilder('char', { length: 36 });
+    target.__tableName = 'users';
+    target.__columnName = 'id';
+    const def = new ColumnBuilder('char', { length: 36 })
+      .references(() => target, { onDelete: 'cascade' })
+      .build('user_id');
+    expect(def.references).toEqual({ table: 'users', column: 'id', onDelete: 'cascade' });
+  });
+
+  it('supports all portable types', () => {
+    expect(new ColumnBuilder('text').build('a').type).toBe('text');
+    expect(new ColumnBuilder('boolean').build('a').type).toBe('boolean');
+    expect(new ColumnBuilder('timestamp').build('a').type).toBe('timestamp');
+    expect(new ColumnBuilder('date').build('a').type).toBe('date');
+    expect(new ColumnBuilder('json').build('a').type).toBe('json');
+    expect(new ColumnBuilder('decimal', { precision: 10, scale: 2 }).build('a').type).toBe(
+      'decimal',
+    );
+    expect(new ColumnBuilder('integer').build('a').type).toBe('integer');
+  });
+});

package/db/src/schema-builder/column-builder.ts

@@ -0,0 +1,87 @@
+import type { ColumnDefinition, ReferenceDef } from './types';
+
+type ColumnType =
+  | 'varchar'
+  | 'char'
+  | 'text'
+  | 'bigint'
+  | 'integer'
+  | 'boolean'
+  | 'timestamp'
+  | 'date'
+  | 'enum'
+  | 'json'
+  | 'decimal';
+
+interface ColumnOpts {
+  length?: number;
+  values?: string[];
+  precision?: number;
+  scale?: number;
+}
+
+export class ColumnBuilder {
+  private def: {
+    type: ColumnType;
+    primaryKey?: boolean;
+    autoIncrement?: boolean;
+    notNull?: boolean;
+    unique?: boolean;
+    default?: unknown;
+    length?: number;
+    values?: string[];
+    precision?: number;
+    scale?: number;
+    references?: ReferenceDef;
+  };
+  private customDbName?: string;
+  __tableName?: string;
+  __columnName?: string;
+
+  constructor(type: ColumnType, opts?: ColumnOpts) {
+    this.def = { type };
+    if (opts?.length !== undefined) this.def.length = opts.length;
+    if (opts?.values !== undefined) this.def.values = opts.values;
+    if (opts?.precision !== undefined) this.def.precision = opts.precision;
+    if (opts?.scale !== undefined) this.def.scale = opts.scale;
+  }
+
+  dbName(name: string): this {
+    this.customDbName = name;
+    return this;
+  }
+  primaryKey(): this {
+    this.def.primaryKey = true;
+    return this;
+  }
+  autoIncrement(): this {
+    this.def.autoIncrement = true;
+    return this;
+  }
+  notNull(): this {
+    this.def.notNull = true;
+    return this;
+  }
+  unique(): this {
+    this.def.unique = true;
+    return this;
+  }
+  default(value: unknown): this {
+    this.def.default = value;
+    return this;
+  }
+
+  references(fn: () => ColumnBuilder, opts?: { onDelete?: ReferenceDef['onDelete'] }): this {
+    const target = fn();
+    const tbl = target.__tableName ?? (target as any).table?.[Symbol.for('drizzle:Name')];
+    const col = target.__columnName ?? (target as any).name;
+    if (!tbl || !col)
+      throw new Error('references() target not fully initialized (missing table/column name)');
+    this.def.references = { table: tbl, column: col, onDelete: opts?.onDelete };
+    return this;
+  }
+
+  build(name: string): ColumnDefinition {
+    return { name: this.customDbName ?? name, ...this.def } as ColumnDefinition;
+  }
+}

package/db/src/schema-builder/compile-d1.test.ts

@@ -0,0 +1,60 @@
+import { describe, it, expect } from 'vitest';
+import { compileD1 } from './compile-d1';
+import type { SchemaDefinition } from './types';
+
+const schema: SchemaDefinition = {
+  users: {
+    name: 'users',
+    columns: {
+      id: { type: 'char', name: 'id', length: 36, primaryKey: true },
+      email: { type: 'varchar', name: 'email', length: 255, unique: true, notNull: true },
+      name: { type: 'varchar', name: 'name', length: 100 },
+      role: { type: 'enum', name: 'role', values: ['admin', 'user'], default: 'user' },
+      age: { type: 'integer', name: 'age' },
+      active: { type: 'boolean', name: 'active', default: true },
+      createdAt: { type: 'timestamp', name: 'created_at', notNull: true },
+    },
+  },
+};
+
+describe('compileD1', () => {
+  it('returns compiled table objects', () => {
+    const result = compileD1(schema);
+    expect(result.users).toBeDefined();
+  });
+
+  it('compiled table has column accessors', () => {
+    const result = compileD1(schema);
+    expect(typeof (result.users as any).id).toBe('object');
+    expect(typeof (result.users as any).email).toBe('object');
+  });
+
+  it('boolean mapped to integer mode boolean', () => {
+    const result = compileD1(schema);
+    expect((result.users as any).active).toBeDefined();
+  });
+
+  it('handles references between tables', () => {
+    const s: SchemaDefinition = {
+      users: {
+        name: 'users',
+        columns: { id: { type: 'char', name: 'id', length: 36, primaryKey: true } },
+      },
+      posts: {
+        name: 'posts',
+        columns: {
+          id: { type: 'integer', name: 'id', primaryKey: true, autoIncrement: true },
+          authorId: {
+            type: 'char',
+            name: 'author_id',
+            length: 36,
+            notNull: true,
+            references: { table: 'users', column: 'id', onDelete: 'cascade' },
+          },
+        },
+      },
+    };
+    const result = compileD1(s);
+    expect(result.posts).toBeDefined();
+  });
+});

package/db/src/schema-builder/compile-d1.ts

@@ -0,0 +1,70 @@
+import { sqliteTable, text, integer, real } from 'drizzle-orm/sqlite-core';
+import type { SQLiteTable } from 'drizzle-orm/sqlite-core';
+import type { SchemaDefinition, ColumnDefinition } from './types';
+
+export function compileD1<T extends SchemaDefinition>(schema: T): { [K in keyof T]: SQLiteTable } {
+  const compiled: Record<string, any> = {};
+
+  const dbNameToKey: Record<string, string> = {};
+  for (const key of Object.keys(schema)) {
+    dbNameToKey[schema[key].name] = key;
+  }
+
+  for (const tableName of Object.keys(schema)) {
+    const tableDef = schema[tableName];
+    const builders: Record<string, any> = {};
+    for (const [colName, colDef] of Object.entries(tableDef.columns)) {
+      let col = toD1Column(colDef.name, colDef);
+      if (colDef.references) {
+        const refKey = dbNameToKey[colDef.references.table] ?? colDef.references.table;
+        col = col.references(() => compiled[refKey]?.[colDef.references!.column], {
+          onDelete: colDef.references!.onDelete,
+        });
+      }
+      builders[colName] = col;
+    }
+    compiled[tableName] = sqliteTable(tableDef.name, builders);
+  }
+
+  return compiled as { [K in keyof T]: SQLiteTable };
+}
+
+function toD1Column(name: string, def: ColumnDefinition): any {
+  let col: any;
+  switch (def.type) {
+    case 'varchar':
+    case 'char':
+    case 'text':
+    case 'enum':
+      col = text(name);
+      break;
+    case 'json':
+      col = text(name, { mode: 'json' });
+      break;
+    case 'bigint':
+    case 'integer':
+      col = integer(name);
+      break;
+    case 'boolean':
+      col = integer(name, { mode: 'boolean' });
+      break;
+    case 'timestamp':
+    case 'date':
+      col = integer(name, { mode: 'timestamp' });
+      break;
+    case 'decimal':
+      col = real(name);
+      break;
+    default:
+      col = text(name);
+  }
+  if (def.autoIncrement) {
+    col = col.primaryKey({ autoIncrement: true });
+  } else if (def.primaryKey) {
+    col = col.primaryKey();
+  }
+  if (def.notNull) col = col.notNull();
+  if (def.unique) col = col.unique();
+  if (def.default !== undefined) col = col.default(def.default);
+  return col;
+}