@sena-ai/platform-core 1.4.0

package/src/db/d1/index.ts

@@ -0,0 +1,304 @@
+import { drizzle, type DrizzleD1Database } from 'drizzle-orm/d1'
+import { eq, and, lt } from 'drizzle-orm'
+import type {
+  BotRow,
+  ConfigTokenRow,
+  WorkspaceAdminConfigRow,
+  BotRepository,
+  ConfigTokenRepository,
+  OAuthStateRepository,
+  WorkspaceAdminConfigRepository,
+} from '../../types/repository.js'
+import * as schema from './schema.js'
+
+export type D1Db = DrizzleD1Database<typeof schema>
+
+export function initD1(d1: D1Database): D1Db {
+  return drizzle(d1, { schema })
+}
+
+function rowToBot(row: typeof schema.bots.$inferSelect): BotRow {
+  return {
+    id: row.id,
+    name: row.name,
+    botUsername: row.botUsername,
+    profileImageUrl: row.profileImageUrl,
+    connectKey: row.connectKey,
+    slackAppId: row.slackAppId,
+    slackTeamId: row.slackTeamId,
+    botTokenEnc: row.botTokenEnc,
+    signingSecretEnc: row.signingSecretEnc,
+    clientId: row.clientId,
+    clientSecretEnc: row.clientSecretEnc,
+    manifestJson: row.manifestJson,
+    status: row.status,
+    createdAt: row.createdAt,
+    updatedAt: row.updatedAt,
+  }
+}
+
+function rowToWorkspaceAdminConfig(
+  row: typeof schema.workspaceAdminConfig.$inferSelect,
+): WorkspaceAdminConfigRow {
+  return {
+    workspaceId: row.workspaceId,
+    slackClientId: row.slackClientId,
+    slackClientSecretEnc: row.slackClientSecretEnc,
+    dCookieEnc: row.dCookieEnc,
+    xoxcTokenEnc: row.xoxcTokenEnc,
+    workspaceDomain: row.workspaceDomain,
+    updatedAt: row.updatedAt,
+    updatedByUserId: row.updatedByUserId,
+  }
+}
+
+export interface D1Repositories {
+  bots: BotRepository
+  configTokens: ConfigTokenRepository
+  oauthStates: OAuthStateRepository
+  workspaceAdminConfig: WorkspaceAdminConfigRepository
+}
+
+export function createD1Repositories(db: D1Db): D1Repositories {
+  return {
+    bots: createD1BotRepository(db),
+    configTokens: createD1ConfigTokenRepository(db),
+    oauthStates: createD1OAuthStateRepository(db),
+    workspaceAdminConfig: createD1WorkspaceAdminConfigRepository(db),
+  }
+}
+
+function createD1BotRepository(db: D1Db): BotRepository {
+  return {
+    async findById(id) {
+      const [row] = await db
+        .select()
+        .from(schema.bots)
+        .where(eq(schema.bots.id, id))
+        .limit(1)
+      return row ? rowToBot(row) : null
+    },
+
+    async findByConnectKey(connectKey) {
+      const [row] = await db
+        .select()
+        .from(schema.bots)
+        .where(eq(schema.bots.connectKey, connectKey))
+        .limit(1)
+      return row ? rowToBot(row) : null
+    },
+
+    async findByConnectKeyAndStatus(connectKey, status) {
+      const [row] = await db
+        .select()
+        .from(schema.bots)
+        .where(
+          and(
+            eq(schema.bots.connectKey, connectKey),
+            eq(schema.bots.status, status),
+          ),
+        )
+        .limit(1)
+      return row ? rowToBot(row) : null
+    },
+
+    async findByIdAndStatus(id, status) {
+      const [row] = await db
+        .select()
+        .from(schema.bots)
+        .where(and(eq(schema.bots.id, id), eq(schema.bots.status, status)))
+        .limit(1)
+      return row ? rowToBot(row) : null
+    },
+
+    async findAll() {
+      const rows = await db.select().from(schema.bots).orderBy(schema.bots.createdAt)
+      return rows.map(rowToBot)
+    },
+
+    async findAllSummary() {
+      const rows = await db
+        .select({
+          id: schema.bots.id,
+          name: schema.bots.name,
+          profileImageUrl: schema.bots.profileImageUrl,
+          slackAppId: schema.bots.slackAppId,
+          slackTeamId: schema.bots.slackTeamId,
+          status: schema.bots.status,
+          createdAt: schema.bots.createdAt,
+        })
+        .from(schema.bots)
+        .orderBy(schema.bots.createdAt)
+      return rows
+    },
+
+    async create(bot) {
+      await db.insert(schema.bots).values({
+        id: bot.id,
+        name: bot.name,
+        botUsername: bot.botUsername,
+        profileImageUrl: bot.profileImageUrl,
+        connectKey: bot.connectKey,
+        slackAppId: bot.slackAppId,
+        slackTeamId: bot.slackTeamId,
+        botTokenEnc: bot.botTokenEnc,
+        signingSecretEnc: bot.signingSecretEnc,
+        clientId: bot.clientId,
+        clientSecretEnc: bot.clientSecretEnc,
+        manifestJson: bot.manifestJson,
+        status: bot.status,
+      })
+    },
+
+    async update(id, data) {
+      await db
+        .update(schema.bots)
+        .set({ ...data, updatedAt: new Date() })
+        .where(eq(schema.bots.id, id))
+    },
+
+    async delete(id) {
+      await db.delete(schema.bots).where(eq(schema.bots.id, id))
+    },
+  }
+}
+
+function createD1ConfigTokenRepository(db: D1Db): ConfigTokenRepository {
+  return {
+    async findByWorkspaceId(id) {
+      const [row] = await db
+        .select()
+        .from(schema.configTokens)
+        .where(eq(schema.configTokens.workspaceId, id))
+        .limit(1)
+      if (!row) return null
+      return {
+        workspaceId: row.workspaceId,
+        accessTokenEnc: row.accessTokenEnc,
+        refreshTokenEnc: row.refreshTokenEnc,
+        expiresAt: row.expiresAt,
+        updatedAt: row.updatedAt,
+      }
+    },
+
+    async findAll() {
+      const rows = await db.select().from(schema.configTokens)
+      return rows.map(
+        (row): ConfigTokenRow => ({
+          workspaceId: row.workspaceId,
+          accessTokenEnc: row.accessTokenEnc,
+          refreshTokenEnc: row.refreshTokenEnc,
+          expiresAt: row.expiresAt,
+          updatedAt: row.updatedAt,
+        }),
+      )
+    },
+
+    async upsert(row) {
+      await db
+        .insert(schema.configTokens)
+        .values({
+          workspaceId: row.workspaceId,
+          accessTokenEnc: row.accessTokenEnc,
+          refreshTokenEnc: row.refreshTokenEnc,
+          expiresAt: row.expiresAt,
+        })
+        .onConflictDoUpdate({
+          target: schema.configTokens.workspaceId,
+          set: {
+            accessTokenEnc: row.accessTokenEnc,
+            refreshTokenEnc: row.refreshTokenEnc,
+            expiresAt: row.expiresAt,
+            updatedAt: new Date(),
+          },
+        })
+    },
+  }
+}
+
+function createD1OAuthStateRepository(db: D1Db): OAuthStateRepository {
+  return {
+    async create(row) {
+      await db.insert(schema.oauthStates).values({
+        state: row.state,
+        botId: row.botId,
+        expiresAt: row.expiresAt,
+      })
+    },
+
+    async consume(state) {
+      const [row] = await db
+        .select()
+        .from(schema.oauthStates)
+        .where(eq(schema.oauthStates.state, state))
+        .limit(1)
+      if (!row) return null
+
+      if (row.expiresAt < new Date()) {
+        await db.delete(schema.oauthStates).where(eq(schema.oauthStates.state, state))
+        return null
+      }
+
+      await db.delete(schema.oauthStates).where(eq(schema.oauthStates.state, state))
+
+      return {
+        state: row.state,
+        botId: row.botId,
+        expiresAt: row.expiresAt,
+      }
+    },
+
+    async deleteExpired() {
+      await db.delete(schema.oauthStates).where(lt(schema.oauthStates.expiresAt, new Date()))
+    },
+  }
+}
+
+function createD1WorkspaceAdminConfigRepository(
+  db: D1Db,
+): WorkspaceAdminConfigRepository {
+  return {
+    async findByWorkspaceId(workspaceId) {
+      const [row] = await db
+        .select()
+        .from(schema.workspaceAdminConfig)
+        .where(eq(schema.workspaceAdminConfig.workspaceId, workspaceId))
+        .limit(1)
+      return row ? rowToWorkspaceAdminConfig(row) : null
+    },
+
+    async findAll() {
+      const rows = await db.select().from(schema.workspaceAdminConfig)
+      return rows.map(rowToWorkspaceAdminConfig)
+    },
+
+    async upsert(config) {
+      await db
+        .insert(schema.workspaceAdminConfig)
+        .values({
+          workspaceId: config.workspaceId,
+          slackClientId: config.slackClientId,
+          slackClientSecretEnc: config.slackClientSecretEnc,
+          dCookieEnc: config.dCookieEnc,
+          xoxcTokenEnc: config.xoxcTokenEnc,
+          workspaceDomain: config.workspaceDomain,
+          updatedByUserId: config.updatedByUserId,
+        })
+        .onConflictDoUpdate({
+          target: schema.workspaceAdminConfig.workspaceId,
+          set: {
+            slackClientId: config.slackClientId,
+            slackClientSecretEnc: config.slackClientSecretEnc,
+            dCookieEnc: config.dCookieEnc,
+            xoxcTokenEnc: config.xoxcTokenEnc,
+            workspaceDomain: config.workspaceDomain,
+            updatedByUserId: config.updatedByUserId,
+            updatedAt: new Date(),
+          },
+        })
+    },
+  }
+}
+
+// Re-export schema for migrations
+export { bots, configTokens, oauthStates, workspaceAdminConfig } from './schema.js'

package/src/db/d1/schema.ts

@@ -0,0 +1,62 @@
+import { sqliteTable, text, integer } from 'drizzle-orm/sqlite-core'
+
+/**
+ * SQLite schema for Cloudflare D1.
+ * Equivalent to the MySQL schema in platform-node.
+ */
+
+export const bots = sqliteTable('bots', {
+  id: text('id').primaryKey(),
+  name: text('name').notNull(),
+  botUsername: text('bot_username').notNull().default(''),
+  profileImageUrl: text('profile_image_url'),
+  connectKey: text('connect_key').notNull().unique(),
+  slackAppId: text('slack_app_id'),
+  slackTeamId: text('slack_team_id'),
+  botTokenEnc: text('bot_token_enc'),
+  signingSecretEnc: text('signing_secret_enc'),
+  clientId: text('client_id'),
+  clientSecretEnc: text('client_secret_enc'),
+  manifestJson: text('manifest_json'),
+  status: text('status', { enum: ['pending', 'active', 'disabled'] })
+    .notNull()
+    .default('pending'),
+  createdAt: integer('created_at', { mode: 'timestamp' })
+    .notNull()
+    .$defaultFn(() => new Date()),
+  updatedAt: integer('updated_at', { mode: 'timestamp' })
+    .notNull()
+    .$defaultFn(() => new Date())
+    .$onUpdateFn(() => new Date()),
+})
+
+export const configTokens = sqliteTable('config_tokens', {
+  workspaceId: text('workspace_id').primaryKey(),
+  accessTokenEnc: text('access_token_enc').notNull(),
+  refreshTokenEnc: text('refresh_token_enc').notNull(),
+  expiresAt: integer('expires_at', { mode: 'timestamp' }).notNull(),
+  updatedAt: integer('updated_at', { mode: 'timestamp' })
+    .notNull()
+    .$defaultFn(() => new Date())
+    .$onUpdateFn(() => new Date()),
+})
+
+export const oauthStates = sqliteTable('oauth_states', {
+  state: text('state').primaryKey(),
+  botId: text('bot_id').notNull(),
+  expiresAt: integer('expires_at', { mode: 'timestamp' }).notNull(),
+})
+
+export const workspaceAdminConfig = sqliteTable('workspace_admin_config', {
+  workspaceId: text('workspace_id').primaryKey(),
+  slackClientId: text('slack_client_id'),
+  slackClientSecretEnc: text('slack_client_secret_enc'),
+  dCookieEnc: text('d_cookie_enc'),
+  xoxcTokenEnc: text('xoxc_token_enc'),
+  workspaceDomain: text('workspace_domain'),
+  updatedAt: integer('updated_at', { mode: 'timestamp' })
+    .notNull()
+    .$defaultFn(() => new Date())
+    .$onUpdateFn(() => new Date()),
+  updatedByUserId: text('updated_by_user_id'),
+})

package/src/db/mysql/index.ts

@@ -0,0 +1,301 @@
+import { drizzle, type MySql2Database } from 'drizzle-orm/mysql2'
+import mysql from 'mysql2/promise'
+import { eq, and, lt } from 'drizzle-orm'
+import type {
+  BotRow,
+  ConfigTokenRow,
+  WorkspaceAdminConfigRow,
+  BotRepository,
+  ConfigTokenRepository,
+  OAuthStateRepository,
+  WorkspaceAdminConfigRepository,
+} from '../../types/repository.js'
+import * as schema from './schema.js'
+
+export type MySQLDatabase = MySql2Database<typeof schema>
+
+export async function initMySQLDb(databaseUrl: string): Promise<MySQLDatabase> {
+  const pool = mysql.createPool({
+    uri: databaseUrl,
+    waitForConnections: true,
+    connectionLimit: 10,
+  })
+
+  return drizzle(pool, { schema, mode: 'default' })
+}
+
+function rowToBot(row: typeof schema.bots.$inferSelect): BotRow {
+  return {
+    id: row.id,
+    name: row.name,
+    botUsername: row.botUsername,
+    profileImageUrl: row.profileImageUrl,
+    connectKey: row.connectKey,
+    slackAppId: row.slackAppId,
+    slackTeamId: row.slackTeamId,
+    botTokenEnc: row.botTokenEnc,
+    signingSecretEnc: row.signingSecretEnc,
+    clientId: row.clientId,
+    clientSecretEnc: row.clientSecretEnc,
+    manifestJson: row.manifestJson,
+    status: row.status,
+    createdAt: row.createdAt,
+    updatedAt: row.updatedAt,
+  }
+}
+
+function rowToWorkspaceAdminConfig(
+  row: typeof schema.workspaceAdminConfig.$inferSelect,
+): WorkspaceAdminConfigRow {
+  return {
+    workspaceId: row.workspaceId,
+    slackClientId: row.slackClientId,
+    slackClientSecretEnc: row.slackClientSecretEnc,
+    dCookieEnc: row.dCookieEnc,
+    xoxcTokenEnc: row.xoxcTokenEnc,
+    workspaceDomain: row.workspaceDomain,
+    updatedAt: row.updatedAt,
+    updatedByUserId: row.updatedByUserId,
+  }
+}
+
+export interface MySQLRepositories {
+  bots: BotRepository
+  configTokens: ConfigTokenRepository
+  oauthStates: OAuthStateRepository
+  workspaceAdminConfig: WorkspaceAdminConfigRepository
+}
+
+export function createMySQLRepositories(db: MySQLDatabase): MySQLRepositories {
+  return {
+    bots: createBotRepository(db),
+    configTokens: createConfigTokenRepository(db),
+    oauthStates: createOAuthStateRepository(db),
+    workspaceAdminConfig: createWorkspaceAdminConfigRepository(db),
+  }
+}
+
+function createBotRepository(db: MySQLDatabase): BotRepository {
+  return {
+    async findById(id) {
+      const [row] = await db.select().from(schema.bots).where(eq(schema.bots.id, id)).limit(1)
+      return row ? rowToBot(row) : null
+    },
+
+    async findByConnectKey(connectKey) {
+      const [row] = await db
+        .select()
+        .from(schema.bots)
+        .where(eq(schema.bots.connectKey, connectKey))
+        .limit(1)
+      return row ? rowToBot(row) : null
+    },
+
+    async findByConnectKeyAndStatus(connectKey, status) {
+      const [row] = await db
+        .select()
+        .from(schema.bots)
+        .where(
+          and(
+            eq(schema.bots.connectKey, connectKey),
+            eq(schema.bots.status, status),
+          ),
+        )
+        .limit(1)
+      return row ? rowToBot(row) : null
+    },
+
+    async findByIdAndStatus(id, status) {
+      const [row] = await db
+        .select()
+        .from(schema.bots)
+        .where(and(eq(schema.bots.id, id), eq(schema.bots.status, status)))
+        .limit(1)
+      return row ? rowToBot(row) : null
+    },
+
+    async findAll() {
+      const rows = await db.select().from(schema.bots).orderBy(schema.bots.createdAt)
+      return rows.map(rowToBot)
+    },
+
+    async findAllSummary() {
+      const rows = await db
+        .select({
+          id: schema.bots.id,
+          name: schema.bots.name,
+          profileImageUrl: schema.bots.profileImageUrl,
+          slackAppId: schema.bots.slackAppId,
+          slackTeamId: schema.bots.slackTeamId,
+          status: schema.bots.status,
+          createdAt: schema.bots.createdAt,
+        })
+        .from(schema.bots)
+        .orderBy(schema.bots.createdAt)
+      return rows
+    },
+
+    async create(bot) {
+      await db.insert(schema.bots).values({
+        id: bot.id,
+        name: bot.name,
+        botUsername: bot.botUsername,
+        profileImageUrl: bot.profileImageUrl,
+        connectKey: bot.connectKey,
+        slackAppId: bot.slackAppId,
+        slackTeamId: bot.slackTeamId,
+        botTokenEnc: bot.botTokenEnc,
+        signingSecretEnc: bot.signingSecretEnc,
+        clientId: bot.clientId,
+        clientSecretEnc: bot.clientSecretEnc,
+        manifestJson: bot.manifestJson,
+        status: bot.status,
+      })
+    },
+
+    async update(id, data) {
+      await db.update(schema.bots).set(data).where(eq(schema.bots.id, id))
+    },
+
+    async delete(id) {
+      await db.delete(schema.bots).where(eq(schema.bots.id, id))
+    },
+  }
+}
+
+function createConfigTokenRepository(db: MySQLDatabase): ConfigTokenRepository {
+  return {
+    async findByWorkspaceId(id) {
+      const [row] = await db
+        .select()
+        .from(schema.configTokens)
+        .where(eq(schema.configTokens.workspaceId, id))
+        .limit(1)
+      if (!row) return null
+      return {
+        workspaceId: row.workspaceId,
+        accessTokenEnc: row.accessTokenEnc,
+        refreshTokenEnc: row.refreshTokenEnc,
+        expiresAt: row.expiresAt,
+        updatedAt: row.updatedAt,
+      }
+    },
+
+    async findAll() {
+      const rows = await db.select().from(schema.configTokens)
+      return rows.map(
+        (row): ConfigTokenRow => ({
+          workspaceId: row.workspaceId,
+          accessTokenEnc: row.accessTokenEnc,
+          refreshTokenEnc: row.refreshTokenEnc,
+          expiresAt: row.expiresAt,
+          updatedAt: row.updatedAt,
+        }),
+      )
+    },
+
+    async upsert(row) {
+      await db
+        .insert(schema.configTokens)
+        .values({
+          workspaceId: row.workspaceId,
+          accessTokenEnc: row.accessTokenEnc,
+          refreshTokenEnc: row.refreshTokenEnc,
+          expiresAt: row.expiresAt,
+        })
+        .onDuplicateKeyUpdate({
+          set: {
+            accessTokenEnc: row.accessTokenEnc,
+            refreshTokenEnc: row.refreshTokenEnc,
+            expiresAt: row.expiresAt,
+          },
+        })
+    },
+  }
+}
+
+function createOAuthStateRepository(db: MySQLDatabase): OAuthStateRepository {
+  return {
+    async create(row) {
+      await db.insert(schema.oauthStates).values({
+        state: row.state,
+        botId: row.botId,
+        expiresAt: row.expiresAt,
+      })
+    },
+
+    async consume(state) {
+      const [row] = await db
+        .select()
+        .from(schema.oauthStates)
+        .where(eq(schema.oauthStates.state, state))
+        .limit(1)
+      if (!row) return null
+
+      if (row.expiresAt < new Date()) {
+        await db.delete(schema.oauthStates).where(eq(schema.oauthStates.state, state))
+        return null
+      }
+
+      await db.delete(schema.oauthStates).where(eq(schema.oauthStates.state, state))
+
+      return {
+        state: row.state,
+        botId: row.botId,
+        expiresAt: row.expiresAt,
+      }
+    },
+
+    async deleteExpired() {
+      await db.delete(schema.oauthStates).where(lt(schema.oauthStates.expiresAt, new Date()))
+    },
+  }
+}
+
+function createWorkspaceAdminConfigRepository(
+  db: MySQLDatabase,
+): WorkspaceAdminConfigRepository {
+  return {
+    async findByWorkspaceId(workspaceId) {
+      const [row] = await db
+        .select()
+        .from(schema.workspaceAdminConfig)
+        .where(eq(schema.workspaceAdminConfig.workspaceId, workspaceId))
+        .limit(1)
+      return row ? rowToWorkspaceAdminConfig(row) : null
+    },
+
+    async findAll() {
+      const rows = await db.select().from(schema.workspaceAdminConfig)
+      return rows.map(rowToWorkspaceAdminConfig)
+    },
+
+    async upsert(config) {
+      await db
+        .insert(schema.workspaceAdminConfig)
+        .values({
+          workspaceId: config.workspaceId,
+          slackClientId: config.slackClientId,
+          slackClientSecretEnc: config.slackClientSecretEnc,
+          dCookieEnc: config.dCookieEnc,
+          xoxcTokenEnc: config.xoxcTokenEnc,
+          workspaceDomain: config.workspaceDomain,
+          updatedByUserId: config.updatedByUserId,
+        })
+        .onDuplicateKeyUpdate({
+          set: {
+            slackClientId: config.slackClientId,
+            slackClientSecretEnc: config.slackClientSecretEnc,
+            dCookieEnc: config.dCookieEnc,
+            xoxcTokenEnc: config.xoxcTokenEnc,
+            workspaceDomain: config.workspaceDomain,
+            updatedByUserId: config.updatedByUserId,
+            updatedAt: new Date(),
+          },
+        })
+    },
+  }
+}
+
+// Re-export schema for drizzle-kit
+export { TABLE_PREFIX, bots, configTokens, oauthStates, workspaceAdminConfig } from './schema.js'