@vobase/core 0.9.0 → 0.11.0

package/src/modules/notify/notify.test.ts

@@ -0,0 +1,145 @@
+import { Database } from 'bun:sqlite';
+import { afterEach, beforeEach, describe, expect, it } from 'bun:test';
+import { drizzle } from 'drizzle-orm/bun-sqlite';
+
+import type { VobaseDb } from '../../db/client';
+import type { EmailProvider, EmailMessage, EmailResult } from '../../contracts/notify';
+import { createNotifyService } from './service';
+import { createResendProvider } from './providers/resend';
+import * as notifySchemaModule from './schema';
+
+function createTestDb(): { db: VobaseDb; sqlite: Database } {
+  const sqlite = new Database(':memory:');
+  sqlite.run('PRAGMA journal_mode=WAL');
+  sqlite.exec(`
+    CREATE TABLE _notify_log (
+      id TEXT PRIMARY KEY,
+      channel TEXT NOT NULL,
+      provider TEXT NOT NULL,
+      "to" TEXT NOT NULL,
+      subject TEXT,
+      template TEXT,
+      provider_message_id TEXT,
+      status TEXT NOT NULL DEFAULT 'sent',
+      error TEXT,
+      created_at INTEGER NOT NULL
+    )
+  `);
+  const db = drizzle({ client: sqlite, schema: notifySchemaModule }) as unknown as VobaseDb;
+  return { db, sqlite };
+}
+
+function createMockEmailProvider(result: EmailResult): EmailProvider {
+  return {
+    async send(_message: EmailMessage) {
+      return result;
+    },
+  };
+}
+
+describe('NotifyService', () => {
+  let db: VobaseDb;
+  let sqlite: Database;
+
+  beforeEach(() => {
+    const result = createTestDb();
+    db = result.db;
+    sqlite = result.sqlite;
+  });
+
+  afterEach(() => {
+    sqlite.close();
+  });
+
+  it('sends email and logs success', async () => {
+    const provider = createMockEmailProvider({ success: true, messageId: 'msg-123' });
+    const svc = createNotifyService({
+      db,
+      emailProvider: provider,
+      emailProviderName: 'resend',
+    });
+
+    const result = await svc.email.send({
+      to: 'user@test.com',
+      subject: 'Test',
+      text: 'Hello',
+    });
+
+    expect(result.success).toBe(true);
+    expect(result.messageId).toBe('msg-123');
+
+    const rows = sqlite.prepare('SELECT * FROM _notify_log').all() as Array<Record<string, unknown>>;
+    expect(rows).toHaveLength(1);
+    expect(rows[0].channel).toBe('email');
+    expect(rows[0].provider).toBe('resend');
+    expect(rows[0].to).toBe('user@test.com');
+    expect(rows[0].subject).toBe('Test');
+    expect(rows[0].status).toBe('sent');
+    expect(rows[0].provider_message_id).toBe('msg-123');
+  });
+
+  it('logs failure when email send fails', async () => {
+    const provider = createMockEmailProvider({ success: false, error: 'API error' });
+    const svc = createNotifyService({
+      db,
+      emailProvider: provider,
+      emailProviderName: 'resend',
+    });
+
+    const result = await svc.email.send({
+      to: 'user@test.com',
+      subject: 'Fail test',
+      text: 'Hello',
+    });
+
+    expect(result.success).toBe(false);
+    expect(result.error).toBe('API error');
+
+    const rows = sqlite.prepare('SELECT * FROM _notify_log').all() as Array<Record<string, unknown>>;
+    expect(rows).toHaveLength(1);
+    expect(rows[0].status).toBe('failed');
+    expect(rows[0].error).toBe('API error');
+  });
+
+  it('throws when accessing unconfigured whatsapp channel', () => {
+    const svc = createNotifyService({
+      db,
+      emailProvider: createMockEmailProvider({ success: true }),
+      emailProviderName: 'resend',
+    });
+
+    expect(() => svc.whatsapp.send).toThrow();
+  });
+
+  it('throws when accessing unconfigured email channel', () => {
+    const svc = createNotifyService({ db });
+
+    expect(() => svc.email.send).toThrow();
+  });
+
+  it('handles multiple recipients', async () => {
+    const provider = createMockEmailProvider({ success: true, messageId: 'multi-123' });
+    const svc = createNotifyService({
+      db,
+      emailProvider: provider,
+      emailProviderName: 'resend',
+    });
+
+    await svc.email.send({
+      to: ['a@test.com', 'b@test.com'],
+      subject: 'Multi',
+      text: 'Hello all',
+    });
+
+    const rows = sqlite.prepare('SELECT "to" FROM _notify_log').all() as Array<Record<string, unknown>>;
+    expect(rows[0].to).toBe('a@test.com,b@test.com');
+  });
+});
+
+describe('Resend Provider', () => {
+  it('returns a provider with send method', () => {
+    const provider = createResendProvider({ apiKey: 'test-key', from: 'test@test.com' });
+    expect(provider).toHaveProperty('send');
+    expect(typeof provider.send).toBe('function');
+  });
+});

package/src/modules/notify/providers/resend.ts

@@ -0,0 +1,47 @@
+import type { EmailProvider, EmailMessage, EmailResult } from '../../../contracts/notify';
+
+export interface ResendConfig {
+  apiKey: string;
+  from: string;
+}
+
+export function createResendProvider(config: ResendConfig): EmailProvider {
+  return {
+    async send(message: EmailMessage): Promise<EmailResult> {
+      const to = Array.isArray(message.to) ? message.to : [message.to];
+
+      try {
+        const response = await fetch('https://api.resend.com/emails', {
+          method: 'POST',
+          headers: {
+            'Authorization': `Bearer ${config.apiKey}`,
+            'Content-Type': 'application/json',
+          },
+          body: JSON.stringify({
+            from: message.from ?? config.from,
+            to,
+            subject: message.subject,
+            html: message.html,
+            text: message.text,
+            cc: message.cc,
+            bcc: message.bcc,
+            reply_to: message.replyTo,
+          }),
+        });
+
+        if (!response.ok) {
+          const body = await response.text();
+          return { success: false, error: `Resend API error (${response.status}): ${body}` };
+        }
+
+        const data = (await response.json()) as { id?: string };
+        return { success: true, messageId: data.id };
+      } catch (err) {
+        return {
+          success: false,
+          error: err instanceof Error ? err.message : String(err),
+        };
+      }
+    },
+  };
+}

package/src/modules/notify/providers/smtp.ts

@@ -0,0 +1,117 @@
+import type { EmailProvider, EmailMessage, EmailResult } from '../../../contracts/notify';
+
+export interface SmtpConfig {
+  host: string;
+  port: number;
+  secure?: boolean;
+  auth?: { user: string; pass: string };
+  from: string;
+}
+
+/**
+ * Minimal SMTP email provider using Bun's TCP socket.
+ * Handles basic SMTP conversation (EHLO, AUTH, MAIL FROM, RCPT TO, DATA, QUIT).
+ * For production use with complex SMTP requirements, consider a dedicated library.
+ */
+export function createSmtpProvider(config: SmtpConfig): EmailProvider {
+  async function sendSmtp(message: EmailMessage): Promise<EmailResult> {
+    const to = Array.isArray(message.to) ? message.to : [message.to];
+    const from = message.from ?? config.from;
+
+    try {
+      const socket = await Bun.connect({
+        hostname: config.host,
+        port: config.port,
+        tls: config.secure ?? config.port === 465,
+        socket: {
+          data(_socket, data) {
+            responses.push(new TextDecoder().decode(data));
+          },
+          open() {},
+          close() {},
+          error(_socket, err) {
+            lastError = err;
+          },
+        },
+      });
+
+      const responses: string[] = [];
+      let lastError: Error | undefined;
+
+      const send = (cmd: string) => {
+        socket.write(new TextEncoder().encode(`${cmd}\r\n`));
+      };
+
+      const wait = (ms = 500) => new Promise<void>((r) => setTimeout(r, ms));
+
+      // Wait for greeting
+      await wait(300);
+
+      send(`EHLO localhost`);
+      await wait(200);
+
+      // AUTH if configured
+      if (config.auth) {
+        const credentials = Buffer.from(`\0${config.auth.user}\0${config.auth.pass}`).toString('base64');
+        send(`AUTH PLAIN ${credentials}`);
+        await wait(200);
+      }
+
+      send(`MAIL FROM:<${from}>`);
+      await wait(100);
+
+      for (const recipient of to) {
+        send(`RCPT TO:<${recipient}>`);
+        await wait(100);
+      }
+
+      send('DATA');
+      await wait(100);
+
+      // Build email headers and body
+      const headers = [
+        `From: ${from}`,
+        `To: ${to.join(', ')}`,
+        `Subject: ${message.subject}`,
+        `Date: ${new Date().toUTCString()}`,
+        `MIME-Version: 1.0`,
+      ];
+
+      if (message.cc?.length) {
+        headers.push(`Cc: ${message.cc.join(', ')}`);
+      }
+
+      if (message.replyTo) {
+        headers.push(`Reply-To: ${message.replyTo}`);
+      }
+
+      if (message.html) {
+        headers.push('Content-Type: text/html; charset=utf-8');
+        send(`${headers.join('\r\n')}\r\n\r\n${message.html}\r\n.`);
+      } else {
+        headers.push('Content-Type: text/plain; charset=utf-8');
+        send(`${headers.join('\r\n')}\r\n\r\n${message.text ?? ''}\r\n.`);
+      }
+
+      await wait(200);
+
+      send('QUIT');
+      await wait(100);
+
+      socket.end();
+
+      if (lastError) {
+        return { success: false, error: lastError.message };
+      }
+
+      return { success: true };
+    } catch (err) {
+      return {
+        success: false,
+        error: err instanceof Error ? err.message : String(err),
+      };
+    }
+  }
+
+  return { send: sendSmtp };
+}

package/src/modules/notify/providers/waba.ts

@@ -0,0 +1,82 @@
+import type { WhatsAppProvider, WhatsAppMessage, WhatsAppResult } from '../../../contracts/notify';
+
+export interface WabaConfig {
+  phoneNumberId: string;
+  accessToken: string;
+  apiVersion?: string;
+}
+
+/**
+ * WhatsApp Business API (WABA) provider.
+ * Uses the Graph API to send template and text messages.
+ */
+export function createWabaProvider(config: WabaConfig): WhatsAppProvider {
+  const apiVersion = config.apiVersion ?? 'v21.0';
+  const baseUrl = `https://graph.facebook.com/${apiVersion}/${config.phoneNumberId}/messages`;
+
+  return {
+    async send(message: WhatsAppMessage): Promise<WhatsAppResult> {
+      try {
+        let body: Record<string, unknown>;
+
+        if (message.template) {
+          // Template message
+          const components = message.template.parameters?.length
+            ? [{
+                type: 'body',
+                parameters: message.template.parameters.map((p) => ({
+                  type: 'text',
+                  text: p,
+                })),
+              }]
+            : undefined;
+
+          body = {
+            messaging_product: 'whatsapp',
+            to: message.to,
+            type: 'template',
+            template: {
+              name: message.template.name,
+              language: { code: message.template.language },
+              ...(components && { components }),
+            },
+          };
+        } else if (message.text) {
+          // Text message
+          body = {
+            messaging_product: 'whatsapp',
+            to: message.to,
+            type: 'text',
+            text: { body: message.text },
+          };
+        } else {
+          return { success: false, error: 'Message must have either template or text' };
+        }
+
+        const response = await fetch(baseUrl, {
+          method: 'POST',
+          headers: {
+            'Authorization': `Bearer ${config.accessToken}`,
+            'Content-Type': 'application/json',
+          },
+          body: JSON.stringify(body),
+        });
+
+        if (!response.ok) {
+          const errorBody = await response.text();
+          return { success: false, error: `WABA API error (${response.status}): ${errorBody}` };
+        }
+
+        const data = (await response.json()) as { messages?: Array<{ id: string }> };
+        const messageId = data.messages?.[0]?.id;
+
+        return { success: true, messageId };
+      } catch (err) {
+        return {
+          success: false,
+          error: err instanceof Error ? err.message : String(err),
+        };
+      }
+    },
+  };
+}

package/src/modules/notify/schema.ts

@@ -0,0 +1,27 @@
+import { index, integer, sqliteTable, text } from 'drizzle-orm/sqlite-core';
+
+import { nanoidPrimaryKey } from '../../db/helpers';
+
+export const notifyLog = sqliteTable(
+  '_notify_log',
+  {
+    id: nanoidPrimaryKey(),
+    channel: text('channel').notNull(),
+    provider: text('provider').notNull(),
+    to: text('to').notNull(),
+    subject: text('subject'),
+    template: text('template'),
+    providerMessageId: text('provider_message_id'),
+    status: text('status').notNull().default('sent'),
+    error: text('error'),
+    createdAt: integer('created_at', { mode: 'timestamp_ms' })
+      .notNull()
+      .$defaultFn(() => new Date()),
+  },
+  (table) => [
+    index('notify_log_channel_idx').on(table.channel),
+    index('notify_log_status_idx').on(table.status),
+  ],
+);
+
+export const notifySchema = { notifyLog };

package/src/modules/notify/service.ts

@@ -0,0 +1,93 @@
+import type { VobaseDb } from '../../db/client';
+import type {
+  EmailProvider,
+  EmailMessage,
+  EmailResult,
+  WhatsAppProvider,
+  WhatsAppMessage,
+  WhatsAppResult,
+} from '../../contracts/notify';
+import { createThrowProxy } from '../../infra/throw-proxy';
+import { notifyLog } from './schema';
+
+export interface EmailChannel {
+  send(message: EmailMessage): Promise<EmailResult>;
+}
+
+export interface WhatsAppChannel {
+  send(message: WhatsAppMessage): Promise<WhatsAppResult>;
+}
+
+export interface NotifyService {
+  email: EmailChannel;
+  whatsapp: WhatsAppChannel;
+}
+
+interface NotifyServiceDeps {
+  db: VobaseDb;
+  emailProvider?: EmailProvider;
+  emailProviderName?: string;
+  whatsappProvider?: WhatsAppProvider;
+  whatsappProviderName?: string;
+}
+
+function logNotification(
+  db: VobaseDb,
+  channel: string,
+  provider: string,
+  to: string,
+  result: { success: boolean; messageId?: string; error?: string },
+  extra?: { subject?: string; template?: string },
+) {
+  db.insert(notifyLog)
+    .values({
+      channel,
+      provider,
+      to,
+      subject: extra?.subject ?? null,
+      template: extra?.template ?? null,
+      providerMessageId: result.messageId ?? null,
+      status: result.success ? 'sent' : 'failed',
+      error: result.error ?? null,
+    })
+    .run();
+}
+
+export function createNotifyService(deps: NotifyServiceDeps): NotifyService {
+  const { db } = deps;
+
+  const email: EmailChannel = deps.emailProvider
+    ? (() => {
+        const provider = deps.emailProvider;
+        const providerName = deps.emailProviderName ?? 'unknown';
+        return {
+          async send(message) {
+            const result = await provider.send(message);
+            const to = Array.isArray(message.to) ? message.to.join(',') : message.to;
+            logNotification(db, 'email', providerName, to, result, {
+              subject: message.subject,
+            });
+            return result;
+          },
+        };
+      })()
+    : createThrowProxy<EmailChannel>('email notify channel');
+
+  const whatsapp: WhatsAppChannel = deps.whatsappProvider
+    ? (() => {
+        const provider = deps.whatsappProvider;
+        const providerName = deps.whatsappProviderName ?? 'unknown';
+        return {
+          async send(message) {
+            const result = await provider.send(message);
+            logNotification(db, 'whatsapp', providerName, message.to, result, {
+              template: message.template?.name,
+            });
+            return result;
+          },
+        };
+      })()
+    : createThrowProxy<WhatsAppChannel>('WhatsApp notify channel');
+
+  return { email, whatsapp };
+}

package/src/modules/sequences/index.ts

@@ -0,0 +1,15 @@
+import { Hono } from 'hono';
+import { defineBuiltinModule } from '../../module';
+import { sequences } from './schema';
+
+export { sequences } from './schema';
+export { nextSequence, type SequenceOptions } from './next-sequence';
+
+export function createSequencesModule() {
+  return defineBuiltinModule({
+    name: '_sequences',
+    schema: { sequences },
+    routes: new Hono(),
+    init: () => {},
+  });
+}

package/src/modules/sequences/next-sequence.ts

@@ -0,0 +1,48 @@
+import { createNanoid } from '../../db/helpers';
+import type { VobaseDb } from '../../db/client';
+
+export interface SequenceOptions {
+  padLength?: number;
+  separator?: string;
+  yearPrefix?: boolean;
+}
+
+const generateSequenceId = createNanoid();
+
+interface SequenceRow {
+  currentValue: number;
+}
+
+export function nextSequence(
+  db: VobaseDb,
+  prefix: string,
+  options?: SequenceOptions,
+): string {
+  const padLength = options?.padLength ?? 4;
+  const separator = options?.separator ?? '-';
+  const yearPrefix = options?.yearPrefix ?? false;
+  const now = Date.now();
+
+  const statement = db.$client.prepare(`
+    INSERT INTO _sequences (id, prefix, current_value, updated_at)
+    VALUES (?, ?, 1, ?)
+    ON CONFLICT (prefix) DO UPDATE
+    SET current_value = current_value + 1, updated_at = ?
+    RETURNING current_value AS currentValue;
+  `);
+
+  const row = statement.get(generateSequenceId(), prefix, now, now) as
+    | SequenceRow
+    | undefined;
+  if (!row) {
+    throw new Error(`Failed to generate next sequence for prefix: ${prefix}`);
+  }
+
+  const formattedValue = String(row.currentValue).padStart(padLength, '0');
+  if (yearPrefix) {
+    const year = new Date(now).getFullYear();
+    return `${prefix}${separator}${year}${separator}${formattedValue}`;
+  }
+
+  return `${prefix}${separator}${formattedValue}`;
+}

package/src/modules/sequences/schema.ts

@@ -0,0 +1,12 @@
+import { integer, sqliteTable, text } from 'drizzle-orm/sqlite-core';
+import { nanoidPrimaryKey } from '../../db/helpers';
+
+export const sequences = sqliteTable('_sequences', {
+  id: nanoidPrimaryKey(),
+  prefix: text('prefix').notNull().unique(),
+  currentValue: integer('current_value').notNull().default(0),
+  updatedAt: integer('updated_at', { mode: 'timestamp_ms' })
+    .notNull()
+    .$defaultFn(() => new Date())
+    .$onUpdate(() => new Date()),
+});

package/src/modules/storage/index.ts

@@ -0,0 +1,44 @@
+import { defineBuiltinModule } from '../../module';
+import { createLocalProvider } from './providers/local';
+import { createS3Provider } from './providers/s3';
+import { createStorageRoutes } from './routes';
+import { createStorageService, type StorageService, type BucketConfig } from './service';
+import { storageSchema } from './schema';
+import type { StorageProviderConfig } from '../../contracts/storage';
+import type { VobaseDb } from '../../db/client';
+
+export interface StorageModuleConfig {
+  provider: StorageProviderConfig;
+  buckets: Record<string, BucketConfig>;
+}
+
+export function createStorageModule(db: VobaseDb, config: StorageModuleConfig) {
+  let service: StorageService;
+
+  if (config.provider.type === 'local') {
+    const provider = createLocalProvider(config.provider);
+    service = createStorageService(provider, config.buckets, db);
+  } else if (config.provider.type === 's3') {
+    const provider = createS3Provider(config.provider);
+    service = createStorageService(provider, config.buckets, db);
+  } else {
+    throw new Error(`Unknown storage provider type`);
+  }
+
+  const routes = createStorageRoutes(service);
+
+  const mod = defineBuiltinModule({
+    name: '_storage',
+    schema: storageSchema,
+    routes,
+  });
+
+  return { ...mod, service };
+}
+
+export { storageObjects, storageSchema } from './schema';
+export { createStorageService } from './service';
+export type { StorageService, BucketConfig, BucketHandle, StorageObject, BucketListOptions } from './service';
+export { createLocalProvider } from './providers/local';
+export { createS3Provider } from './providers/s3';
+export { createStorageRoutes } from './routes';