@rx-ted/packages-honest-plugins 1.0.1

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

@@ -0,0 +1,64 @@
+import { describe, it, expect } from 'vitest';
+import { getTableName } from 'drizzle-orm';
+import { compileMysql } from './compile-mysql';
+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' },
+      meta: { type: 'json', name: 'meta' },
+      createdAt: { type: 'timestamp', name: 'created_at', notNull: true },
+    },
+  },
+};
+
+describe('compileMysql', () => {
+  it('returns compiled table objects', () => {
+    const result = compileMysql(schema);
+    expect(result.users).toBeDefined();
+  });
+
+  it('compiled table has column accessors', () => {
+    const result = compileMysql(schema);
+    const u = result.users as any;
+    expect(typeof u.id).toBe('object');
+    expect(typeof u.email).toBe('object');
+    expect(typeof u.role).toBe('object');
+  });
+
+  it('compiled table name matches', () => {
+    const result = compileMysql(schema);
+    expect(getTableName(result.users)).toBe('users');
+  });
+
+  it('handles schema with two tables and FK reference', () => {
+    const schemaWithFk: SchemaDefinition = {
+      users: {
+        name: 'users',
+        columns: { id: { type: 'char', name: 'id', length: 36, primaryKey: true } },
+      },
+      user_auth: {
+        name: 'user_auth',
+        columns: {
+          id: { type: 'integer', name: 'id', autoIncrement: true, primaryKey: true },
+          userId: {
+            type: 'char',
+            name: 'user_id',
+            length: 36,
+            notNull: true,
+            references: { table: 'users', column: 'id', onDelete: 'cascade' },
+          },
+        },
+      },
+    };
+    const result = compileMysql(schemaWithFk);
+    expect(result.users).toBeDefined();
+    expect(result.user_auth).toBeDefined();
+  });
+});

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

@@ -0,0 +1,102 @@
+import {
+  mysqlTable,
+  varchar,
+  char,
+  text,
+  int,
+  bigint,
+  boolean,
+  datetime,
+  date,
+  mysqlEnum,
+  json,
+  decimal,
+} from 'drizzle-orm/mysql-core';
+import type { MySqlTableWithColumns } from 'drizzle-orm/mysql-core';
+import type { TableDefinition, ColumnDefinition } from './types';
+
+type AnyMySqlTable<N extends string = string> = MySqlTableWithColumns<{
+  name: N;
+  columns: Record<string, any>;
+  dialect: string;
+  schema: string | undefined;
+}>;
+
+export function compileMysql<T extends Record<string, TableDefinition>>(
+  schema: T,
+): { [K in keyof T]: T[K] extends TableDefinition<infer N> ? AnyMySqlTable<N & string> : never } {
+  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 = toMysqlColumn(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] = mysqlTable(tableDef.name, builders);
+  }
+
+  return compiled as any;
+}
+
+function toMysqlColumn(name: string, def: ColumnDefinition): any {
+  let col: any;
+  switch (def.type) {
+    case 'varchar':
+      col = varchar(name, { length: def.length ?? 255 });
+      break;
+    case 'char':
+      col = char(name, { length: def.length ?? 1 });
+      break;
+    case 'text':
+      col = text(name);
+      break;
+    case 'bigint':
+      col = bigint(name, { mode: 'number', unsigned: true });
+      break;
+    case 'integer':
+      col = int(name);
+      break;
+    case 'boolean':
+      col = boolean(name);
+      break;
+    case 'timestamp':
+      col = datetime(name);
+      break;
+    case 'date':
+      col = date(name);
+      break;
+    case 'enum':
+      col =
+        def.values && def.values.length > 0
+          ? mysqlEnum(name, def.values as [string, ...string[]])
+          : text(name);
+      break;
+    case 'json':
+      col = json(name);
+      break;
+    case 'decimal':
+      col = decimal(name, { precision: def.precision, scale: def.scale });
+      break;
+    default:
+      col = text(name);
+  }
+  if (def.primaryKey) col = col.primaryKey();
+  if (def.autoIncrement) col = col.autoincrement();
+  if (def.notNull) col = col.notNull();
+  if (def.unique) col = col.unique();
+  if (def.default !== undefined) col = col.default(def.default);
+  return col;
+}

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

@@ -0,0 +1,36 @@
+import { describe, it, expect } from 'vitest';
+import { t, table, compileSchema } from './index';
+
+describe('compileSchema dispatcher', () => {
+  const schema = {
+    users: table('users', {
+      id: t.char(36).primaryKey(),
+      email: t.varchar(255).unique().notNull(),
+    }),
+  };
+
+  it('compileSchema with mysql dialect', () => {
+    const result = compileSchema('mysql', schema);
+    expect(result.users).toBeDefined();
+    expect(typeof (result.users as any).id).toBe('object');
+  });
+
+  it('compileSchema with d1 dialect', () => {
+    const result = compileSchema('d1', schema);
+    expect(result.users).toBeDefined();
+    expect(typeof (result.users as any).id).toBe('object');
+  });
+
+  it('compileSchema with sqlite dialect', () => {
+    const result = compileSchema('sqlite', schema);
+    expect(result.users).toBeDefined();
+    expect(typeof (result.users as any).id).toBe('object');
+  });
+
+  it('sqlite produces same column types as d1', () => {
+    const sqlite = compileSchema('sqlite', schema);
+    const d1 = compileSchema('d1', schema);
+    expect(sqlite.users.constructor.name).toBe('SQLiteTable');
+    expect(d1.users.constructor.name).toBe('SQLiteTable');
+  });
+});

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

@@ -0,0 +1,41 @@
+export { t, table } from './table-builder';
+export type {
+  Dialect,
+  ColumnDefinition,
+  TableDefinition,
+  SchemaDefinition,
+  ReferenceDef,
+} from './types';
+export { compileMysql } from './compile-mysql';
+export { compileD1 } from './compile-d1';
+export {
+  zdb,
+  getZodDbMeta,
+  isZodObject,
+  toTableDefinition,
+  toColumnDefinition,
+} from './zod-bridge';
+export type { ZodDbMeta } from './zod-bridge';
+import { isZodObject, toTableDefinition } from './zod-bridge';
+import type { Dialect } from './types';
+import { compileMysql } from './compile-mysql';
+import { compileD1 } from './compile-d1';
+
+export function compileSchema<T extends Record<string, any>>(
+  dialect: Dialect,
+  schema: T,
+): Record<string, any> {
+  const definitions: Record<string, any> = {};
+  for (const [name, def] of Object.entries(schema)) {
+    definitions[name] = isZodObject(def) ? toTableDefinition(name, def) : def;
+  }
+  switch (dialect) {
+    case 'mysql':
+      return compileMysql(definitions);
+    case 'd1':
+    case 'sqlite':
+      return compileD1(definitions);
+    default:
+      throw new Error(`Unknown dialect: ${dialect}`);
+  }
+}

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

@@ -0,0 +1,55 @@
+import { describe, it, expect } from 'vitest';
+import { t, table } from './table-builder';
+
+describe('table builder DSL', () => {
+  it('t.varchar creates builder with length', () => {
+    const def = t.varchar(255).build('email');
+    expect(def.type).toBe('varchar');
+    expect(def.length).toBe(255);
+  });
+
+  it('t supports all portable types', () => {
+    expect(t.char(36).build('a').type).toBe('char');
+    expect(t.text().build('a').type).toBe('text');
+    expect(t.bigint().build('a').type).toBe('bigint');
+    expect(t.integer().build('a').type).toBe('integer');
+    expect(t.boolean().build('a').type).toBe('boolean');
+    expect(t.timestamp().build('a').type).toBe('timestamp');
+    expect(t.date().build('a').type).toBe('date');
+    expect(t.enum(['x', 'y']).build('a').type).toBe('enum');
+    expect(t.json().build('a').type).toBe('json');
+    expect(t.decimal(10, 2).build('a').type).toBe('decimal');
+  });
+
+  it('table() creates TableDefinition with column names', () => {
+    const users = table('users', {
+      id: t.char(36).primaryKey(),
+      email: t.varchar(255).unique().notNull(),
+      name: t.varchar(100),
+    });
+    expect(users.name).toBe('users');
+    expect(Object.keys(users.columns)).toEqual(['id', 'email', 'name']);
+    expect(users.columns.id.primaryKey).toBe(true);
+    expect(users.columns.email.unique).toBe(true);
+  });
+
+  it('table() sets table/column names on builders for references', () => {
+    const users = table('users', { id: t.char(36).primaryKey() });
+    expect(users.columns.id.name).toBe('id');
+  });
+
+  it('two tables with foreign key reference', () => {
+    const users = table('users', {
+      id: t.char(36).primaryKey(),
+    });
+    const posts = table('posts', {
+      id: t.char(36).primaryKey(),
+      authorId: t.char(36).references(() => users.id),
+    });
+    expect(posts.columns.authorId.references).toEqual({
+      table: 'users',
+      column: 'id',
+      onDelete: undefined,
+    });
+  });
+});

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

@@ -0,0 +1,50 @@
+import { ColumnBuilder } from './column-builder';
+import type { TableDefinition, ColumnDefinition } from './types';
+
+function c(
+  type: ConstructorParameters<typeof ColumnBuilder>[0],
+  opts?: ConstructorParameters<typeof ColumnBuilder>[1],
+) {
+  return new ColumnBuilder(type, opts);
+}
+
+export const t = {
+  varchar: (length: number) => c('varchar', { length }),
+  char: (length: number) => c('char', { length }),
+  text: () => c('text'),
+  bigint: () => c('bigint'),
+  integer: () => c('integer'),
+  boolean: () => c('boolean'),
+  timestamp: () => c('timestamp'),
+  date: () => c('date'),
+  enum: (values: string[]) => c('enum', { values }),
+  json: () => c('json'),
+  decimal: (p: number, s: number) => c('decimal', { precision: p, scale: s }),
+};
+
+export function table<N extends string>(
+  name: N,
+  columns: Record<string, ColumnBuilder>,
+): TableDefinition<N> {
+  const defs: Record<string, ColumnDefinition> = {};
+  for (const [colName, builder] of Object.entries(columns)) {
+    builder.__tableName = name;
+    builder.__columnName = colName;
+    defs[colName] = builder.build(colName);
+  }
+  const tbl: TableDefinition<N> = { name, columns: defs };
+  return proxyTable(tbl, columns);
+}
+
+function proxyTable<N extends string>(
+  tbl: TableDefinition<N>,
+  columns: Record<string, ColumnBuilder>,
+): TableDefinition<N> {
+  return new Proxy(tbl, {
+    get(target, prop) {
+      if (prop in target) return (target as any)[prop];
+      if (typeof prop === 'string' && prop in columns) return columns[prop];
+      return undefined;
+    },
+  }) as unknown as TableDefinition<N>;
+}

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

@@ -0,0 +1,68 @@
+import { describe, it, expect } from 'vitest';
+import type { ColumnDefinition, TableDefinition, SchemaDefinition } from './types';
+
+describe('schema-builder types', () => {
+  it('ColumnDefinition shape with common fields', () => {
+    const col: ColumnDefinition = {
+      type: 'varchar',
+      name: 'email',
+      length: 255,
+      notNull: true,
+      unique: true,
+    };
+    expect(col.type).toBe('varchar');
+    expect(col.notNull).toBe(true);
+  });
+
+  it('ColumnDefinition supports autoIncrement', () => {
+    const col: ColumnDefinition = {
+      type: 'integer',
+      name: 'id',
+      autoIncrement: true,
+      primaryKey: true,
+    };
+    expect(col.autoIncrement).toBe(true);
+  });
+
+  it('ColumnDefinition supports enum values and default', () => {
+    const col: ColumnDefinition = {
+      type: 'enum',
+      name: 'role',
+      values: ['admin', 'user'],
+      default: 'user',
+    };
+    expect(col.values).toEqual(['admin', 'user']);
+    expect(col.default).toBe('user');
+  });
+
+  it('ColumnDefinition supports precision and scale', () => {
+    const col: ColumnDefinition = { type: 'decimal', name: 'price', precision: 10, scale: 2 };
+    expect(col.precision).toBe(10);
+    expect(col.scale).toBe(2);
+  });
+
+  it('ColumnDefinition supports references with onDelete', () => {
+    const col: ColumnDefinition = {
+      type: 'char',
+      name: 'user_id',
+      length: 36,
+      references: { table: 'users', column: 'id', onDelete: 'cascade' },
+    };
+    expect(col.references?.table).toBe('users');
+    expect(col.references?.onDelete).toBe('cascade');
+  });
+
+  it('TableDefinition shape', () => {
+    const t: TableDefinition = {
+      name: 'users',
+      columns: { id: { type: 'char', name: 'id', length: 36, primaryKey: true } },
+    };
+    expect(t.name).toBe('users');
+    expect(t.columns.id.primaryKey).toBe(true);
+  });
+
+  it('SchemaDefinition is record of tables', () => {
+    const s: SchemaDefinition = { users: { name: 'users', columns: {} } };
+    expect(s.users.name).toBe('users');
+  });
+});

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

@@ -0,0 +1,30 @@
+export type Dialect = 'mysql' | 'd1' | 'sqlite';
+
+export interface ReferenceDef {
+  table: string;
+  column: string;
+  onDelete?: 'cascade' | 'set null' | 'restrict' | 'no action';
+}
+
+export interface ColumnDefinition {
+  type: string;
+  /** DB column name (distinct from the Record key which is the JS property name) */
+  name: string;
+  primaryKey?: boolean;
+  autoIncrement?: boolean;
+  notNull?: boolean;
+  unique?: boolean;
+  default?: unknown;
+  length?: number;
+  values?: string[];
+  precision?: number;
+  scale?: number;
+  references?: ReferenceDef;
+}
+
+export interface TableDefinition<N extends string = string> {
+  name: N;
+  columns: Record<string, ColumnDefinition>;
+}
+
+export type SchemaDefinition = Record<string, TableDefinition>;

package/db/src/schema-builder/zod-bridge.ts

@@ -0,0 +1,89 @@
+import { z } from 'zod';
+import type { ColumnDefinition, ReferenceDef } from './types';
+
+const DB_COL = Symbol('zod:db-col');
+
+export interface ZodDbMeta {
+  type:
+    | 'varchar'
+    | 'char'
+    | 'text'
+    | 'bigint'
+    | 'integer'
+    | 'boolean'
+    | 'timestamp'
+    | 'date'
+    | 'enum'
+    | 'json'
+    | 'decimal';
+  dbName?: string;
+  primaryKey?: boolean;
+  autoIncrement?: boolean;
+  notNull?: boolean;
+  unique?: boolean;
+  default?: unknown;
+  length?: number;
+  values?: string[];
+  precision?: number;
+  scale?: number;
+  references?: ReferenceDef;
+}
+
+export function zdb<T extends z.ZodType>(zod: T, meta: ZodDbMeta): T {
+  Object.defineProperty(zod, DB_COL, {
+    value: meta,
+    writable: true,
+    configurable: true,
+  });
+  return zod;
+}
+
+export function getZodDbMeta(zod: z.ZodType): ZodDbMeta | undefined {
+  return (zod as any)[DB_COL];
+}
+
+export function isZodObject(schema: unknown): schema is z.ZodObject<any> {
+  return typeof schema === 'object' && schema !== null && 'shape' in schema;
+}
+
+export function toColumnDefinition(jsName: string, zod: z.ZodType): ColumnDefinition {
+  const meta = getZodDbMeta(zod);
+  if (!meta) {
+    const inner = (zod as any)._def?.innerType;
+    if (zod instanceof z.ZodDefault && inner) {
+      return toColumnDefinition(jsName, inner);
+    }
+    if (zod instanceof z.ZodNullable && inner) {
+      return toColumnDefinition(jsName, inner);
+    }
+    if (zod instanceof z.ZodOptional && inner) {
+      return toColumnDefinition(jsName, inner);
+    }
+    throw new Error(`Column "${jsName}" has no db metadata. Use zdb() to attach metadata.`);
+  }
+  return {
+    name: meta.dbName ?? jsName,
+    type: meta.type,
+    primaryKey: meta.primaryKey,
+    autoIncrement: meta.autoIncrement,
+    notNull: meta.notNull,
+    unique: meta.unique,
+    default: meta.default,
+    length: meta.length,
+    values: meta.values,
+    precision: meta.precision,
+    scale: meta.scale,
+    references: meta.references,
+  };
+}
+
+export function toTableDefinition(
+  name: string,
+  schema: z.ZodObject<any>,
+): { name: string; columns: Record<string, ColumnDefinition> } {
+  const columns: Record<string, ColumnDefinition> = {};
+  for (const [key, zod] of Object.entries(schema.shape)) {
+    columns[key] = toColumnDefinition(key, zod as z.ZodType);
+  }
+  return { name, columns };
+}

package/db/src/sqlite/index.ts

@@ -0,0 +1,14 @@
+export {
+  sqliteTable,
+  text,
+  integer,
+  real,
+  blob,
+  uniqueIndex,
+  index,
+  primaryKey,
+  foreignKey,
+} from 'drizzle-orm/sqlite-core';
+export type { BaseSQLiteDatabase } from 'drizzle-orm/sqlite-core';
+export { SqlitePlugin } from './plugin';
+export type { SqlitePluginOptions } from './plugin';

package/db/src/sqlite/plugin.ts

@@ -0,0 +1,46 @@
+import type { Hono } from 'hono';
+import type { IPlugin, Application } from '@rx-ted/packages-honest';
+import { ComponentManager, resolvePluginLogger } from '@rx-ted/packages-honest';
+import { ENV_SYMBOL, type Env, type ILogger } from '@rx-ted/packages-core';
+import { createClient } from '@libsql/client';
+import { drizzle } from 'drizzle-orm/libsql';
+import { DB_GLOBAL_KEY } from '../constants';
+import { assertRuntimeSupport, type AppRuntime } from '../resolve';
+
+export interface SqlitePluginOptions {
+  dbPath: string;
+  schema: Record<string, any>;
+}
+
+export class SqlitePlugin implements IPlugin {
+  readonly name = 'sqlite-plugin';
+  readonly version = '0.0.1';
+  logger?: ILogger;
+  private db: any = null;
+
+  constructor(private options: SqlitePluginOptions) {}
+
+  async beforeModulesRegistered(_app: Application, _hono: Hono): Promise<void> {
+    this.logger ??= resolvePluginLogger(this.name);
+
+    const env = ComponentManager.getPlugin<Env>(ENV_SYMBOL);
+    assertRuntimeSupport(env.platform as AppRuntime, 'sqlite');
+
+    this.logger.info(`connecting to SQLite: ${this.options.dbPath}`);
+
+    const client = createClient({ url: `file:${this.options.dbPath}` });
+    const raw = drizzle(client, { schema: this.options.schema });
+    this.db = raw;
+
+    ComponentManager.registerPlugin(DB_GLOBAL_KEY, this.db);
+
+    this.logger.info(`SQLite connected: ${this.options.dbPath}`);
+  }
+
+  async close(): Promise<void> {
+    if (this.db?.$client) {
+      this.db.$client.close();
+      this.logger?.info('SQLite connection closed');
+    }
+  }
+}

package/db/src/types.ts

@@ -0,0 +1,45 @@
+export interface PreparedStatement {
+  execute(params?: unknown[]): Promise<QueryResult>;
+  release(): void;
+}
+
+export interface DatabaseConnection {
+  prepare(sql: string): PreparedStatement;
+  query<T>(sql: string, params?: unknown[]): Promise<T[]>;
+  execute(sql: string, params?: unknown[]): Promise<QueryResult>;
+  release(): void;
+}
+
+export interface DatabaseClient {
+  prepare(sql: string): PreparedStatement;
+  getConnection(): Promise<DatabaseConnection>;
+  close(): Promise<void>;
+}
+
+export interface QueryResult {
+  affectedRows: number;
+  insertId?: number;
+}
+
+export interface DatabaseDriver {
+  query<T = unknown>(sql: string, params?: unknown[]): Promise<T[]>;
+  execute(sql: string, params?: unknown[]): Promise<QueryResult>;
+  transaction<T>(fn: (driver: DatabaseDriver) => Promise<T>): Promise<T>;
+  close(): Promise<void>;
+  healthCheck(): Promise<boolean>;
+}
+
+export interface QueryOptions {
+  where?: Record<string, any>;
+  orderBy?: Record<string, 'asc' | 'desc'>;
+  pagination?: { page: number; pageSize: number };
+  include?: string[];
+}
+
+export interface PaginationResult<T> {
+  data: T[];
+  total: number;
+  page: number;
+  pageSize: number;
+  totalPages: number;
+}

package/db/tsconfig.json

@@ -0,0 +1,21 @@
+{
+  "compilerOptions": {
+    "target": "es2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "strict": true,
+    "declaration": true,
+    "sourceMap": false,
+    "experimentalDecorators": true,
+    "emitDecoratorMetadata": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "isolatedModules": true,
+    "verbatimModuleSyntax": true,
+    "types": ["node"],
+    "rootDir": "./src",
+    "outDir": "./dist"
+  },
+  "include": ["src"],
+  "exclude": ["**/*.test.ts"]
+}

package/db/vitest.config.ts

@@ -0,0 +1,13 @@
+import { defineConfig } from 'vitest/config';
+import { getWorkspaceAliases } from '../../../vitest.workspace-aliases';
+
+export default defineConfig({
+  resolve: {
+    alias: getWorkspaceAliases(),
+  },
+  test: {
+    globals: true,
+    environment: 'node',
+    exclude: ['node_modules'],
+  },
+});

package/mail/.turbo/turbo-build.log

@@ -0,0 +1 @@
+$ tsc -p tsconfig.json