@vobase/core 0.9.0 → 0.11.0

package/src/ctx.test.ts

@@ -0,0 +1,162 @@
+import { describe, expect, it } from 'bun:test';
+import { Hono } from 'hono';
+
+import {
+  contextMiddleware,
+  getCtx,
+  type VobaseCtx,
+  type VobaseUser,
+} from './ctx';
+import type { VobaseDb } from './db';
+import type { HttpClient } from './infra/http-client';
+import type { Scheduler } from './infra/queue';
+import type { NotifyService } from './modules/notify/service';
+import type { StorageService } from './modules/storage/service';
+
+const db = {} as VobaseDb;
+const scheduler: Scheduler = {
+  async add() {},
+};
+const storage: StorageService = {
+  bucket() {
+    throw new Error('not implemented');
+  },
+};
+const notify: NotifyService = {
+  email: { send: async () => ({ success: true }) },
+  whatsapp: { send: async () => ({ success: true }) },
+};
+const mockResponse = { ok: true, status: 200, headers: new Headers(), data: null, raw: new Response() };
+const http: HttpClient = {
+  fetch: async () => mockResponse,
+  get: async () => mockResponse,
+  post: async () => mockResponse,
+  put: async () => mockResponse,
+  delete: async () => mockResponse,
+} as HttpClient;
+
+function expectType<T>(_value: T): void {}
+
+describe('ctx helpers', () => {
+  it('getCtx(c) returns all properties when set', async () => {
+    const user: VobaseUser = {
+      id: 'user_123',
+      email: 'user@example.com',
+      name: 'Test User',
+      role: 'admin',
+    };
+
+    const app = new Hono();
+    app.use('*', async (c, next) => {
+      c.set('db', db);
+      c.set('scheduler', scheduler);
+      c.set('storage', storage);
+      c.set('notify', notify);
+      c.set('http', http);
+      c.set('user', user);
+      await next();
+    });
+    app.get('/', (c) => {
+      const ctx = getCtx(c);
+      return c.json({
+        hasDb: ctx.db === db,
+        hasScheduler: ctx.scheduler === scheduler,
+        hasStorage: ctx.storage === storage,
+        hasNotify: ctx.notify === notify,
+        hasHttp: ctx.http === http,
+        user: ctx.user,
+      });
+    });
+
+    const response = await app.request('http://localhost/');
+    const body = (await response.json()) as {
+      hasDb: boolean;
+      hasScheduler: boolean;
+      hasStorage: boolean;
+      hasNotify: boolean;
+      hasHttp: boolean;
+      user: VobaseUser | null;
+    };
+
+    expect(response.status).toBe(200);
+    expect(body.hasDb).toBe(true);
+    expect(body.hasScheduler).toBe(true);
+    expect(body.hasStorage).toBe(true);
+    expect(body.hasNotify).toBe(true);
+    expect(body.hasHttp).toBe(true);
+    expect(body.user).toEqual(user);
+  });
+
+  it('returns null user when session middleware did not set user', async () => {
+    const app = new Hono();
+    app.use('*', contextMiddleware({ db, scheduler, storage, notify, http }));
+    app.get('/', (c) => c.json({ user: getCtx(c).user }));
+
+    const response = await app.request('http://localhost/');
+    const body = (await response.json()) as { user: VobaseUser | null };
+
+    expect(response.status).toBe(200);
+    expect(body.user).toBeNull();
+  });
+
+  it('contextMiddleware sets db, scheduler, storage, and http', async () => {
+    const app = new Hono();
+    app.use('*', contextMiddleware({ db, scheduler, storage, notify, http }));
+    app.get('/', (c) => {
+      return c.json({
+        hasDb: c.get('db') === db,
+        hasScheduler: c.get('scheduler') === scheduler,
+        hasStorage: c.get('storage') === storage,
+        hasHttp: c.get('http') === http,
+      });
+    });
+
+    const response = await app.request('http://localhost/');
+    const body = (await response.json()) as {
+      hasDb: boolean;
+      hasScheduler: boolean;
+      hasStorage: boolean;
+      hasHttp: boolean;
+    };
+
+    expect(response.status).toBe(200);
+    expect(body.hasDb).toBe(true);
+    expect(body.hasScheduler).toBe(true);
+    expect(body.hasStorage).toBe(true);
+    expect(body.hasHttp).toBe(true);
+  });
+
+  it('getCtx(c) includes http client', async () => {
+    const app = new Hono();
+    app.use('*', contextMiddleware({ db, scheduler, storage, notify, http }));
+    app.get('/', (c) => {
+      const ctx = getCtx(c);
+      return c.json({ hasHttp: ctx.http === http });
+    });
+
+    const response = await app.request('http://localhost/');
+    const body = (await response.json()) as { hasHttp: boolean };
+
+    expect(response.status).toBe(200);
+    expect(body.hasHttp).toBe(true);
+  });
+
+  it('exposes correctly typed properties on VobaseCtx', async () => {
+    const app = new Hono();
+    app.use('*', contextMiddleware({ db, scheduler, storage, notify, http }));
+    app.get('/', (c) => {
+      const ctx = getCtx(c);
+      expectType<VobaseCtx>(ctx);
+      expectType<VobaseDb>(ctx.db);
+      expectType<VobaseUser | null>(ctx.user);
+      expectType<Scheduler>(ctx.scheduler);
+      expectType<StorageService>(ctx.storage);
+      expectType<NotifyService>(ctx.notify);
+      expectType<HttpClient>(ctx.http);
+      return c.text('ok');
+    });
+
+    const response = await app.request('http://localhost/');
+    expect(response.status).toBe(200);
+  });
+});

package/src/ctx.ts

@@ -0,0 +1,64 @@
+import type { Context } from 'hono';
+import { createMiddleware } from 'hono/factory';
+
+import type { VobaseDb } from './db';
+import type { HttpClient } from './infra/http-client';
+import type { Scheduler } from './infra/queue';
+import type { NotifyService } from './modules/notify/service';
+import type { StorageService } from './modules/storage/service';
+
+export interface VobaseUser {
+  id: string;
+  email: string;
+  name: string;
+  role: string;
+  /** Set when the user has an active organization (better-auth organization plugin) */
+  activeOrganizationId?: string;
+}
+
+export interface VobaseCtx {
+  db: VobaseDb;
+  user: VobaseUser | null;
+  scheduler: Scheduler;
+  storage: StorageService;
+  notify: NotifyService;
+  http: HttpClient;
+}
+
+declare module 'hono' {
+  interface ContextVariableMap {
+    db: VobaseDb;
+    scheduler: Scheduler;
+    storage: StorageService;
+    notify: NotifyService;
+    http: HttpClient;
+  }
+}
+
+export function contextMiddleware(deps: {
+  db: VobaseDb;
+  scheduler: Scheduler;
+  storage: StorageService;
+  notify: NotifyService;
+  http: HttpClient;
+}) {
+  return createMiddleware(async (c, next) => {
+    c.set('db', deps.db);
+    c.set('scheduler', deps.scheduler);
+    c.set('storage', deps.storage);
+    c.set('notify', deps.notify);
+    c.set('http', deps.http);
+    await next();
+  });
+}
+
+export function getCtx(c: Context): VobaseCtx {
+  return {
+    db: c.get('db'),
+    user: c.get('user') ?? null,
+    scheduler: c.get('scheduler'),
+    storage: c.get('storage'),
+    notify: c.get('notify'),
+    http: c.get('http'),
+  };
+}

package/src/db/client.test.ts

@@ -0,0 +1,75 @@
+import { rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { resolve } from 'node:path';
+import type { Database } from 'bun:sqlite';
+import { afterEach, describe, expect, it } from 'bun:test';
+
+import { createDatabase } from './client';
+
+type DbWithClient = ReturnType<typeof createDatabase> & { $client: Database };
+
+const tempDbPaths = new Set<string>();
+
+function getPragmaValue(db: DbWithClient, pragma: string): string {
+  const result = db.$client.query(`PRAGMA ${pragma}`).get() as Record<
+    string,
+    unknown
+  >;
+  return String(Object.values(result)[0]);
+}
+
+function closeDatabase(db: DbWithClient): void {
+  db.$client.close();
+}
+
+afterEach(() => {
+  for (const dbPath of tempDbPaths) {
+    rmSync(dbPath, { force: true });
+  }
+  tempDbPaths.clear();
+});
+
+describe('createDatabase', () => {
+  it('creates an in-memory drizzle database client', () => {
+    const db = createDatabase(':memory:') as DbWithClient;
+
+    expect(db).toBeDefined();
+    expect(db.$client).toBeDefined();
+
+    closeDatabase(db);
+  });
+
+  it('sets PRAGMA busy_timeout to 5000', () => {
+    const db = createDatabase(':memory:') as DbWithClient;
+
+    expect(getPragmaValue(db, 'busy_timeout')).toBe('5000');
+
+    closeDatabase(db);
+  });
+
+  it('sets PRAGMA synchronous to NORMAL (1)', () => {
+    const db = createDatabase(':memory:') as DbWithClient;
+
+    expect(getPragmaValue(db, 'synchronous')).toBe('1');
+
+    closeDatabase(db);
+  });
+
+  it('sets PRAGMA foreign_keys to ON (1)', () => {
+    const db = createDatabase(':memory:') as DbWithClient;
+
+    expect(getPragmaValue(db, 'foreign_keys')).toBe('1');
+
+    closeDatabase(db);
+  });
+
+  it('sets PRAGMA journal_mode to WAL for file databases', () => {
+    const dbPath = resolve(tmpdir(), `vobase-client-${Date.now()}.db`);
+    tempDbPaths.add(dbPath);
+    const db = createDatabase(dbPath) as DbWithClient;
+
+    expect(getPragmaValue(db, 'journal_mode')).toBe('wal');
+
+    closeDatabase(db);
+  });
+});

package/src/db/client.ts

@@ -0,0 +1,15 @@
+import { Database } from 'bun:sqlite';
+import { drizzle } from 'drizzle-orm/bun-sqlite';
+
+export type VobaseDb = ReturnType<typeof drizzle>;
+
+export function createDatabase(dbPath: string): VobaseDb {
+  const sqlite = new Database(dbPath);
+
+  sqlite.run('PRAGMA journal_mode=WAL');
+  sqlite.run('PRAGMA busy_timeout=5000');
+  sqlite.run('PRAGMA synchronous=NORMAL');
+  sqlite.run('PRAGMA foreign_keys=ON');
+
+  return drizzle({ client: sqlite });
+}

package/src/db/helpers.test.ts

@@ -0,0 +1,147 @@
+import { describe, expect, it } from 'bun:test';
+
+import {
+  createNanoid,
+  DEFAULT_COLUMNS,
+  NANOID_ALPHABET,
+  NANOID_LENGTH,
+  nanoidPrimaryKey,
+} from './helpers';
+
+// Drizzle marks `.config` as protected; bracket access bypasses this for test inspection
+function getConfig(col: unknown): Record<string, unknown> {
+  return (col as Record<string, Record<string, unknown>>).config;
+}
+
+describe('nanoid helpers', () => {
+  describe('NANOID_LENGTH constants', () => {
+    it('should have SHORT, DEFAULT, and LONG lengths defined', () => {
+      expect(NANOID_LENGTH.SHORT).toBe(8);
+      expect(NANOID_LENGTH.DEFAULT).toBe(12);
+      expect(NANOID_LENGTH.LONG).toBe(16);
+    });
+  });
+
+  describe('NANOID_ALPHABET', () => {
+    it('should only contain lowercase alphanumeric characters', () => {
+      expect(NANOID_ALPHABET).toBe('0123456789abcdefghijklmnopqrstuvwxyz');
+    });
+  });
+
+  describe('createNanoid()', () => {
+    it('should generate IDs of the correct length', () => {
+      const generateShort = createNanoid(NANOID_LENGTH.SHORT);
+      const generateDefault = createNanoid(NANOID_LENGTH.DEFAULT);
+      const generateLong = createNanoid(NANOID_LENGTH.LONG);
+
+      expect(generateShort().length).toBe(8);
+      expect(generateDefault().length).toBe(12);
+      expect(generateLong().length).toBe(16);
+    });
+
+    it('should generate IDs using only the alphabet', () => {
+      const generate = createNanoid(NANOID_LENGTH.DEFAULT);
+      const id = generate();
+
+      for (const char of id) {
+        expect(NANOID_ALPHABET.includes(char)).toBe(true);
+      }
+    });
+
+    it('should cache generators and reuse them', () => {
+      const gen1 = createNanoid(NANOID_LENGTH.DEFAULT);
+      const gen2 = createNanoid(NANOID_LENGTH.DEFAULT);
+
+      // Should be the same function instance (cached)
+      expect(gen1).toBe(gen2);
+    });
+
+    it('should generate unique IDs', () => {
+      const generate = createNanoid(NANOID_LENGTH.DEFAULT);
+      const ids = new Set();
+
+      for (let i = 0; i < 1000; i++) {
+        ids.add(generate());
+      }
+
+      expect(ids.size).toBe(1000);
+    });
+
+    it('should use default length when not specified', () => {
+      const generate = createNanoid();
+      expect(generate().length).toBe(NANOID_LENGTH.DEFAULT);
+    });
+  });
+
+  describe('nanoidPrimaryKey()', () => {
+    it('should create a text column named "id"', () => {
+      const column = nanoidPrimaryKey();
+      expect(getConfig(column).name).toBe('id');
+    });
+
+    it('should be a primary key', () => {
+      const column = nanoidPrimaryKey();
+      expect(getConfig(column).primaryKey).toBe(true);
+    });
+
+    it('should have a default function', () => {
+      const column = nanoidPrimaryKey();
+      expect(typeof column.$default).toBe('function');
+    });
+
+    it('should generate valid nanoid', () => {
+      // createNanoid() returns a generator function
+      const generator = createNanoid();
+      const id = generator();
+
+      expect(id).toBeDefined();
+      expect(typeof id).toBe('string');
+      expect(id.length).toBe(NANOID_LENGTH.DEFAULT);
+    });
+
+    it('should support custom lengths', () => {
+      const columnShort = nanoidPrimaryKey(NANOID_LENGTH.SHORT);
+      const columnLong = nanoidPrimaryKey(NANOID_LENGTH.LONG);
+
+      expect(getConfig(columnShort).name).toBe('id');
+      expect(getConfig(columnLong).name).toBe('id');
+    });
+  });
+
+  describe('DEFAULT_COLUMNS', () => {
+    it('should have createdAt and updatedAt columns', () => {
+      expect(DEFAULT_COLUMNS.createdAt).toBeDefined();
+      expect(DEFAULT_COLUMNS.updatedAt).toBeDefined();
+    });
+
+    it('createdAt should be an integer column with timestamp_ms mode', () => {
+      const col = DEFAULT_COLUMNS.createdAt;
+      expect(getConfig(col).name).toBe('created_at');
+      expect(getConfig(col).mode).toBe('timestamp_ms');
+      expect(getConfig(col).hasDefault).toBe(true);
+      expect(getConfig(col).notNull).toBe(true);
+    });
+
+    it('updatedAt should be an integer column with timestamp_ms mode', () => {
+      const col = DEFAULT_COLUMNS.updatedAt;
+      expect(getConfig(col).name).toBe('updated_at');
+      expect(getConfig(col).mode).toBe('timestamp_ms');
+      expect(getConfig(col).hasDefault).toBe(true);
+      expect(getConfig(col).notNull).toBe(true);
+    });
+
+    it('timestamps should have default functions', () => {
+      expect(typeof DEFAULT_COLUMNS.createdAt.$default).toBe('function');
+      expect(typeof DEFAULT_COLUMNS.updatedAt.$default).toBe('function');
+    });
+
+    it('updatedAt should have onUpdate function', () => {
+      expect(typeof DEFAULT_COLUMNS.updatedAt.$onUpdate).toBe('function');
+    });
+
+    it('timestamp columns should use integer data type', () => {
+      expect(getConfig(DEFAULT_COLUMNS.createdAt).dataType).toBe('object date');
+      expect(getConfig(DEFAULT_COLUMNS.updatedAt).dataType).toBe('object date');
+    });
+  });
+});

package/src/db/helpers.ts

@@ -0,0 +1,51 @@
+import { integer, text } from 'drizzle-orm/sqlite-core';
+import { customAlphabet } from 'nanoid';
+
+export const NANOID_LENGTH = { SHORT: 8, DEFAULT: 12, LONG: 16 } as const;
+export const NANOID_ALPHABET = '0123456789abcdefghijklmnopqrstuvwxyz';
+
+// Cache generators to avoid recreating
+const nanoidGenerators = new Map<number, () => string>();
+
+/**
+ * Create or retrieve a cached nanoid generator with the specified length.
+ * Uses a custom alphabet of lowercase alphanumeric characters.
+ */
+export function createNanoid(
+  length: number = NANOID_LENGTH.DEFAULT,
+): () => string {
+  if (!nanoidGenerators.has(length)) {
+    nanoidGenerators.set(length, customAlphabet(NANOID_ALPHABET, length));
+  }
+  const generator = nanoidGenerators.get(length);
+
+  if (!generator) {
+    throw new Error(`No nanoid generator for length ${length}`);
+  }
+
+  return generator;
+}
+
+/**
+ * Create a nanoid-based primary key column for SQLite.
+ * Generates a 12-character ID by default (customizable).
+ */
+export const nanoidPrimaryKey = (length: number = NANOID_LENGTH.DEFAULT) =>
+  text('id')
+    .primaryKey()
+    .$defaultFn(() => createNanoid(length)());
+
+/**
+ * Default timestamp columns for SQLite using timestamp_ms mode.
+ * createdAt: set on insert and never updated
+ * updatedAt: set on insert and updated on every row modification
+ */
+export const DEFAULT_COLUMNS = {
+  createdAt: integer('created_at', { mode: 'timestamp_ms' })
+    .notNull()
+    .$defaultFn(() => new Date()),
+  updatedAt: integer('updated_at', { mode: 'timestamp_ms' })
+    .notNull()
+    .$defaultFn(() => new Date())
+    .$onUpdate(() => new Date()),
+} as const;

package/src/db/index.ts

@@ -0,0 +1,8 @@
+export { createDatabase, type VobaseDb } from './client';
+export {
+  createNanoid,
+  DEFAULT_COLUMNS,
+  NANOID_ALPHABET,
+  NANOID_LENGTH,
+  nanoidPrimaryKey,
+} from './helpers';

package/{dist/index.d.ts → src/index.ts}

@@ -1,45 +1,144 @@
+// Engine
 export { type CreateAppConfig, createApp } from './app';
+
+// Auth Module
 export { createAuthModule, type AuthModuleConfig, type AuthModule } from './modules/auth';
 export { sessionMiddleware, optionalSessionMiddleware } from './modules/auth/middleware';
+
+// Auth Schema (tables managed by better-auth)
+export {
+  authUser,
+  authSession,
+  authAccount,
+  authVerification,
+  authApikey,
+  authOrganization,
+  authMember,
+  authInvitation,
+} from './modules/auth/schema';
+
+// RBAC
+export { requireRole, requirePermission, requireOrg } from './modules/auth/permissions';
+export type { Permission, OrganizationContext } from './contracts/permissions';
+
+// Contracts
 export type { AuthAdapter, AuthSession, AuthUser } from './contracts/auth';
-export type { StorageProvider, UploadOptions, PresignOptions, ListOptions, StorageListResult, StorageObjectInfo, LocalProviderConfig, S3ProviderConfig, StorageProviderConfig, } from './contracts/storage';
-export type { EmailProvider, EmailMessage, EmailAttachment, EmailResult, WhatsAppProvider, WhatsAppMessage, WhatsAppResult, } from './contracts/notify';
+export type {
+  StorageProvider,
+  UploadOptions,
+  PresignOptions,
+  ListOptions,
+  StorageListResult,
+  StorageObjectInfo,
+  LocalProviderConfig,
+  S3ProviderConfig,
+  StorageProviderConfig,
+} from './contracts/storage';
+export type {
+  EmailProvider,
+  EmailMessage,
+  EmailAttachment,
+  EmailResult,
+  WhatsAppProvider,
+  WhatsAppMessage,
+  WhatsAppResult,
+} from './contracts/notify';
 export type { ModuleInitContext } from './contracts/module';
+
+// Context
 export type { VobaseCtx, VobaseUser } from './ctx';
 export { contextMiddleware, getCtx } from './ctx';
+
+// Circuit Breaker
 export { CircuitBreaker, type CircuitBreakerOptions } from './infra/circuit-breaker';
-export { createHttpClient, type HttpClient, type HttpClientOptions, type HttpResponse, type RequestOptions, } from './infra/http-client';
+
+// HTTP Client
+export {
+  createHttpClient,
+  type HttpClient,
+  type HttpClientOptions,
+  type HttpResponse,
+  type RequestOptions,
+} from './infra/http-client';
+
+// DB
 export { createDatabase, type VobaseDb } from './db';
-export { createNanoid, DEFAULT_COLUMNS, NANOID_ALPHABET, NANOID_LENGTH, nanoidPrimaryKey, } from './db/helpers';
-export { conflict, dbBusy, ERROR_CODES, type ErrorCode, errorHandler, forbidden, notFound, unauthorized, VobaseError, validation, } from './infra/errors';
+export {
+  createNanoid,
+  DEFAULT_COLUMNS,
+  NANOID_ALPHABET,
+  NANOID_LENGTH,
+  nanoidPrimaryKey,
+} from './db/helpers';
+
+// Errors
+export {
+  conflict,
+  dbBusy,
+  ERROR_CODES,
+  type ErrorCode,
+  errorHandler,
+  forbidden,
+  notFound,
+  unauthorized,
+  VobaseError,
+  validation,
+} from './infra/errors';
+
+// Jobs
 export type { JobDefinition, JobHandler, WorkerOptions } from './infra/job';
 export { createWorker, defineJob } from './infra/job';
+
+// Logger
 export { logger } from './infra/logger';
+
+// Auth Audit Hooks (re-exported from auth module)
 export { createAuthAuditHooks } from './modules/auth/audit-hooks';
+
+// Module
 export type { DefineModuleConfig, VobaseModule } from './module';
 export { defineModule } from './module';
+
+// Module Registry
 export { registerModules } from './module-registry';
+
+// Queue
 export { createScheduler, type JobOptions, type Scheduler } from './infra/queue';
+
+// Built-in Modules: Audit
 export { createAuditModule, auditLog, recordAudits } from './modules/audit';
 export { trackChanges } from './modules/audit/track-changes';
 export { requestAuditMiddleware } from './modules/audit/middleware';
+
+// Built-in Modules: Sequences
 export { createSequencesModule, sequences } from './modules/sequences';
 export { nextSequence, type SequenceOptions } from './modules/sequences/next-sequence';
+
+// Built-in Modules: Credentials
 export { createCredentialsModule, credentialsTable } from './modules/credentials';
 export { encrypt, decrypt, getCredential, setCredential, deleteCredential } from './modules/credentials/encrypt';
+
+// Schemas
 export { getActiveSchemas, type SchemaConfig } from './schemas';
+
+// Throw Proxy
 export { createThrowProxy } from './infra/throw-proxy';
+
+// Built-in Modules: Storage
 export { createStorageModule, type StorageModuleConfig } from './modules/storage';
 export { createLocalProvider } from './modules/storage/providers/local';
 export { createS3Provider } from './modules/storage/providers/s3';
 export { createStorageRoutes } from './modules/storage/routes';
 export { storageObjects } from './modules/storage/schema';
 export type { StorageService, BucketConfig, BucketHandle, StorageObject, BucketListOptions } from './modules/storage/service';
+
+// Built-in Modules: Notify
 export { createNotifyModule, type NotifyModuleConfig } from './modules/notify';
 export { notifyLog } from './modules/notify/schema';
 export { createResendProvider, type ResendConfig } from './modules/notify/providers/resend';
 export { createSmtpProvider, type SmtpConfig } from './modules/notify/providers/smtp';
 export { createWabaProvider, type WabaConfig } from './modules/notify/providers/waba';
 export type { NotifyService, EmailChannel, WhatsAppChannel } from './modules/notify/service';
+
+// Webhooks
 export { type WebhookConfig, verifyHmacSignature, createWebhookRoutes, webhookDedup } from './infra/webhooks';
-//# sourceMappingURL=index.d.ts.map