@maestro-js/agent-skills 1.0.0-alpha.2 → 1.0.0-alpha.21

package/skills/maestro-examples/references/chorus/packages/services/src/auth/auth-use-cases.ts

@@ -0,0 +1,178 @@
+import z from 'zod'
+import { authenticatableDbProvider } from './authenticatable-db-provider.ts'
+import { profileDbProvider } from '../profile/profile-db-provider.ts'
+import { ProfileSchemas } from '@chorus/schemas'
+import { CustomErrors } from '@maestro-js/custom-errors'
+import { Hash } from '@maestro-js/hash'
+import { Auth } from '@maestro-js/auth'
+import { Password } from '@maestro-js/password'
+import { Mail } from '@maestro-js/mail'
+import { RateLimiting } from '@maestro-js/rate-limiting'
+import type { Session } from '@maestro-js/session'
+import { renderEmailTemplate } from '@chorus/email-templates'
+import { durationFns, type Iso } from 'iso-fns'
+import type { DeviceContext } from '../maestro.ts'
+import { SignedUrl } from '@maestro-js/signed-url'
+import { FileStorage } from '@maestro-js/file-storage'
+import { createAvatar } from '@dicebear/core'
+import { initials } from '@dicebear/collection'
+
+export const SignUpDuplicateProfileError = CustomErrors.create({
+  name: 'DuplicateProfile',
+  message: 'A user that email already exists'
+})
+
+export const InvalidCredentialsError = CustomErrors.create<{ remaining: number }>({
+  name: 'InvalidCredentials',
+  message: ({ remaining }) =>
+    remaining < 5 ? `Incorrect email or password. ${remaining + 1} attempts remaining.` : 'Incorrect email or password'
+})
+
+export const TooManyLoginAttemptsError = CustomErrors.create<{ availableIn: Iso.Duration | null }>({
+  name: 'TooManyLoginAttempts',
+  message: ({ availableIn }) =>
+    availableIn
+      ? `Too many attempts. Try again in ${durationFns.getMinutes(durationFns.round(availableIn, { smallestUnit: 'minutes', largestUnit: 'minute', roundingMode: 'ceil' }))} minutes`
+      : 'Too many attempts.'
+})
+
+const isTesting = process.env.IS_TESTING === 'true'
+
+export const GetProfileById = z
+  .function({
+    input: [z.object({ profileId: z.number() })]
+  })
+  .implement(async ({ profileId }) => {
+    return profileDbProvider.getProfileById(profileId)
+  })
+
+export const SignupNewProfile = z
+  .function({
+    input: [ProfileSchemas.signupSchema]
+  })
+  .implement(async ({ email: emailRaw, password }) => {
+    const email = emailRaw.toLowerCase().trim()
+    const existingUser = await authenticatableDbProvider.getAuthenticatableByCredentials({ email })
+
+    if (existingUser) {
+      throw new SignUpDuplicateProfileError()
+    }
+
+    const passwordHash = await Hash.provider('bcrypt').hash(password)
+    const username = email.split('@')[0] ?? 'user'
+
+    const avatar = createAvatar(initials, { seed: username })
+    const svg = avatar.toString()
+    const avatarPath = `profile-images/${username}-${Date.now()}.svg`
+    await FileStorage.put(avatarPath, svg)
+    const profileImage = FileStorage.url(avatarPath)
+
+    const profileId = await profileDbProvider.createProfile({ email, passwordHash, username, profileImage })
+
+    return profileId
+  })
+
+const LOGIN_MAX_ATTEMPTS_PER_EMAIL = 10
+const LOGIN_DECAY_SECONDS = 120
+
+export const LoginProfile = z
+  .function({
+    input: [
+      ProfileSchemas.loginSchema.extend({
+        session: z.custom<Session | Promise<Session>>(),
+        deviceContext: z.custom<DeviceContext>()
+      })
+    ]
+  })
+  .implement(async ({ email: emailRaw, password, rememberMe, session, deviceContext }) => {
+    const email = emailRaw.toLowerCase().trim()
+    const rateLimitingKey = `Auth.login.email.${email}`
+
+    if (!isTesting) {
+      if (await RateLimiting.tooManyAttempts(rateLimitingKey, LOGIN_MAX_ATTEMPTS_PER_EMAIL)) {
+        const availableIn = await RateLimiting.availableIn(rateLimitingKey)
+        throw new TooManyLoginAttemptsError({ availableIn })
+      }
+
+      await RateLimiting.increment(rateLimitingKey, 1, LOGIN_DECAY_SECONDS)
+    }
+    const { id: profileId, cookie } = await Auth.login({
+      credentials: { email, password },
+      rememberMe,
+      deviceContext,
+      session
+    })
+
+    if (!profileId) {
+      const remaining = await RateLimiting.remaining(rateLimitingKey, LOGIN_MAX_ATTEMPTS_PER_EMAIL)
+      throw new InvalidCredentialsError({ remaining })
+    }
+
+    return { profileId, cookie }
+  })
+
+export const LogoutProfile = z
+  .function({
+    input: [
+      z.object({
+        cookieHeader: z.string().nullish(),
+        session: z.custom<Session | Promise<Session>>()
+      })
+    ]
+  })
+  .implement(async ({ cookieHeader, session }) => {
+    const { cookie } = await Auth.logout({ cookieHeader, session })
+
+    return { cookie }
+  })
+
+export const ForgotPassword = z
+  .function({
+    input: [z.object({ email: z.email(), url: z.string() })]
+  })
+  .implement(async ({ email: emailRaw, url }) => {
+    const email = emailRaw.toLowerCase().trim()
+    const user = await authenticatableDbProvider.getAuthenticatableByCredentials({ email })
+
+    if (!user) return
+
+    const token = await Password.createPasswordResetToken(user.id, { expirationMinutes: 15 })
+    const signedUrlSearchParams = await SignedUrl.signURL(
+      new URLSearchParams({
+        token,
+        id: user.id.toString()
+      }),
+      'PT15M'
+    )
+
+    const resetUrlObj = new URL(url)
+    signedUrlSearchParams.forEach((value, key) => resetUrlObj.searchParams.set(key, value))
+    const resetUrl = resetUrlObj.toString()
+    const html = await renderEmailTemplate('password-reset', {
+      resetUrl,
+      expiresInMinutes: 15
+    })
+
+    await Mail.send({
+      to: email,
+      subject: 'Reset Your Password',
+      content: { html }
+    })
+  })
+
+export const ResetPassword = z
+  .function({
+    input: [
+      z.object({
+        token: z.string(),
+        authenticatableId: z.number(),
+        newPassword: z.string(),
+        session: z.custom<Session | Promise<Session>>(),
+        deviceContext: z.custom<DeviceContext>()
+      })
+    ]
+  })
+  .implement(async ({ token, authenticatableId, newPassword, session, deviceContext }) => {
+    await Password.resetPassword({ token, newPassword })
+    return Auth.loginById({ id: authenticatableId, session, deviceContext })
+  })

package/skills/maestro-examples/references/chorus/packages/services/src/auth/authenticatable-db-provider.ts

@@ -0,0 +1,59 @@
+import { Auth } from '@maestro-js/auth'
+import type { Password } from '@maestro-js/password'
+import { Db } from '@maestro-js/db'
+import { isoZ } from '@maestro-js/iso-zod'
+import { instantFns, type Iso } from 'iso-fns'
+import { z } from 'zod'
+
+const authenticatableModel = z.object({
+  id: z.number(),
+  credentialsInvalidBefore: isoZ.instant().nullable()
+})
+
+const passwordAuthenticatableModel = z.object({
+  id: z.number(),
+  passwordHash: z.string(),
+  credentialsInvalidBefore: isoZ.instant().nullable()
+})
+
+async function getAuthenticatableById(id: number): Promise<Auth.Authenticatable | null> {
+  const rows = await Db.select('SELECT profileId AS id, credentialsInvalidBefore FROM profiles WHERE profileId = ?', [id])
+  return rows.length ? authenticatableModel.parse(rows[0]) : null
+}
+
+async function getAuthenticatableByCredentials({
+  email
+}: {
+  email: string
+}): Promise<(Password.Authenticatable<number> & { passwordHash: string }) | null> {
+  const rows = await Db.select(
+    'SELECT profileId AS id, passwordHash, credentialsInvalidBefore FROM profiles WHERE email = ?',
+    [email]
+  )
+  const row = rows[0]
+  if (!row) return null
+  return passwordAuthenticatableModel.parse(row)
+}
+
+async function updatePasswordHash(id: number, passwordHash: string): Promise<void> {
+  await Db.update('UPDATE profiles SET passwordHash = ?, lastModifiedDate = ? WHERE profileId = ?', [
+    passwordHash,
+    instantFns.formatISO9075(instantFns.now()),
+    id
+  ])
+}
+
+async function updateCredentialsInvalidBefore(id: number, date: Iso.Instant): Promise<void> {
+  await Db.update('UPDATE profiles SET credentialsInvalidBefore = ?, lastModifiedDate = ? WHERE profileId = ?', [
+    instantFns.formatISO9075(date),
+    instantFns.formatISO9075(instantFns.now()),
+    id
+  ])
+}
+
+export const authenticatableDbProvider = {
+  getAuthenticatableById,
+  getAuthenticatableByCredentials,
+  updatePasswordHash,
+  updateCredentialsInvalidBefore
+}

package/skills/maestro-examples/references/chorus/packages/services/src/auth/index.ts

@@ -0,0 +1,29 @@
+import {
+  SignUpDuplicateProfileError,
+  InvalidCredentialsError,
+  TooManyLoginAttemptsError,
+  SignupNewProfile,
+  LoginProfile,
+  LogoutProfile,
+  ForgotPassword,
+  ResetPassword,
+  GetProfileById
+} from './auth-use-cases.ts'
+import { Password } from '@maestro-js/password'
+
+export const AuthService = {
+  GetProfileById,
+  SignupNewProfile,
+  LoginProfile,
+  LogoutProfile,
+  ForgotPassword,
+  ResetPassword,
+  errors: {
+    SignUpDuplicateProfileError,
+    InvalidCredentialsError,
+    TooManyLoginAttemptsError,
+    PasswordResetThrottledError: Password.errors.ThrottledError,
+    PasswordResetInvalidTokenError: Password.errors.InvalidTokenError,
+    PasswordResetExpiredTokenError: Password.errors.ExpiredTokenError
+  }
+}

package/skills/maestro-examples/references/chorus/packages/services/src/auth/password-reset-token-db-provider.ts

@@ -0,0 +1,58 @@
+import type { Password } from '@maestro-js/password'
+import { Db } from '@maestro-js/db'
+import { isoZ } from '@maestro-js/iso-zod'
+import { instantFns } from 'iso-fns'
+import { z } from 'zod'
+
+const passwordResetTokenRecordModel = z.object({
+  authenticatableId: z.number(),
+  selector: z.string(),
+  verifierHash: z.string(),
+  expirationDate: isoZ.instant(),
+  createdDate: isoZ.instant()
+})
+
+async function create(record: Password.ResetTokenRecord<number>): Promise<void> {
+  await Db.insert(
+    'INSERT INTO passwordResetTokens (profileId, selector, verifierHash, expirationDate, createdDate) VALUES (?, ?, ?, ?, ?)',
+    [
+      record.authenticatableId,
+      record.selector,
+      record.verifierHash,
+      instantFns.formatISO9075(record.expirationDate),
+      instantFns.formatISO9075(record.createdDate)
+    ]
+  )
+}
+
+async function getBySelector(selector: string): Promise<Password.ResetTokenRecord<number> | null> {
+  const rows = await Db.select('SELECT * FROM passwordResetTokens WHERE selector = ?', [selector])
+  const row = rows[0]
+  if (!row) return null
+  return mapToResetTokenRecord(row)
+}
+
+async function getByAuthenticatableId(authenticatableId: number): Promise<Password.ResetTokenRecord<number> | null> {
+  const rows = await Db.select('SELECT * FROM passwordResetTokens WHERE profileId = ?', [authenticatableId])
+  const row = rows[0]
+  if (!row) return null
+  return mapToResetTokenRecord(row)
+}
+
+async function deleteByAuthenticatableId(authenticatableId: number): Promise<void> {
+  await Db.delete('DELETE FROM passwordResetTokens WHERE profileId = ?', [authenticatableId])
+}
+
+function mapToResetTokenRecord(row: Record<string, unknown>): Password.ResetTokenRecord<number> {
+  return passwordResetTokenRecordModel.parse({
+    ...row,
+    authenticatableId: row.profileId
+  })
+}
+
+export const passwordResetTokenDbProvider = {
+  create,
+  getBySelector,
+  getByAuthenticatableId,
+  deleteByAuthenticatableId
+}

package/skills/maestro-examples/references/chorus/packages/services/src/auth/remember-me-token-db-provider.ts

@@ -0,0 +1,82 @@
+import { Db } from '@maestro-js/db'
+import { isoZ } from '@maestro-js/iso-zod'
+import { instantFns } from 'iso-fns'
+import { z } from 'zod'
+
+const rememberMeTokenRecordModel = z.object({
+  authenticatableId: z.number(),
+  selector: z.string(),
+  verifierHash: z.string(),
+  deviceContext: z.object({
+    ip: z.string().nullable(),
+    userAgent: z.string().nullable()
+  }),
+  expirationDate: isoZ.instant().nullable(),
+  rotatedDate: isoZ.instant().nullable()
+})
+
+type RememberMeTokenRecord = z.infer<typeof rememberMeTokenRecordModel>
+
+async function create(options: RememberMeTokenRecord): Promise<void> {
+  await Db.insert(
+    'INSERT INTO rememberMeTokens (profileId, selector, verifierHash, deviceContext, expirationDate, rotatedDate, createdDate) VALUES (?, ?, ?, ?, ?, ?, ?)',
+    [
+      options.authenticatableId,
+      options.selector,
+      options.verifierHash,
+      JSON.stringify(options.deviceContext),
+      options.expirationDate ? instantFns.formatISO9075(options.expirationDate) : null,
+      options.rotatedDate ? instantFns.formatISO9075(options.rotatedDate) : null,
+      instantFns.formatISO9075(instantFns.now())
+    ]
+  )
+}
+
+async function getBySelector(selector: string): Promise<RememberMeTokenRecord | null> {
+  const rows = await Db.select('SELECT * FROM rememberMeTokens WHERE selector = ?', [selector])
+  const row = rows[0]
+  if (!row) return null
+  return mapToRememberMeTokenRecord(row)
+}
+
+async function rotateBySelector(selector: string, token: { verifierHash: string; selector: string }): Promise<void> {
+  await Db.transaction(async () => {
+    await Db.update('UPDATE rememberMeTokens SET rotatedDate = ? WHERE selector = ?', [
+      instantFns.formatISO9075(instantFns.now()),
+      selector
+    ])
+    await Db.update(
+      `
+      INSERT INTO rememberMeTokens (profileId, selector, verifierHash, deviceContext, expirationDate, rotatedDate, createdDate)
+      SELECT profileId, ? as selector, ? as verifierHash, deviceContext, expirationDate, NULL as rotatedDate, createdDate
+      FROM rememberMeTokens
+      WHERE selector = ?
+    `,
+      [token.selector, token.verifierHash, selector]
+    )
+  })
+}
+
+async function revokeBySelector(selector: string): Promise<void> {
+  await Db.delete('DELETE FROM rememberMeTokens WHERE selector = ?', [selector])
+}
+
+async function revokeByAuthenticatableId(id: number): Promise<void> {
+  await Db.delete('DELETE FROM rememberMeTokens WHERE profileId = ?', [id])
+}
+
+function mapToRememberMeTokenRecord(row: Record<string, unknown>): RememberMeTokenRecord {
+  return rememberMeTokenRecordModel.parse({
+    ...row,
+    authenticatableId: row.profileId,
+    deviceContext: JSON.parse((row.deviceContext as string) ?? '{}')
+  })
+}
+
+export const rememberMeTokenDbProvider = {
+  create,
+  getBySelector,
+  rotateBySelector,
+  revokeBySelector,
+  revokeByAuthenticatableId
+}

package/skills/maestro-examples/references/chorus/packages/services/src/channel/channel-db-provider.test.ts

@@ -0,0 +1,85 @@
+import { test } from 'beartest-js'
+import { expect } from 'expect'
+import { H } from '../testing/index.ts'
+import { channelDbProvider } from './channel-db-provider.ts'
+
+const profile = H.ProfileSeed({ profileId: 1 })
+const profile2 = H.ProfileSeed({ profileId: 2, username: 'moderator-user', email: 'mod@test.com' })
+const pipe = H.SeedPipe(profile, profile2)
+
+test.beforeEach(async () => { await pipe.setup() })
+test.afterEach(async () => { await pipe.teardown() })
+
+test('createChannel and getChannelById', async () => {
+  const id = await channelDbProvider.createChannel({
+    ownerProfileId: 1,
+    name: 'General',
+    slug: 'general',
+    description: 'General discussion'
+  })
+  const channel = await channelDbProvider.getChannelById(id)
+  expect(channel).not.toBeNull()
+  expect(channel!.name).toBe('General')
+  expect(channel!.slug).toBe('general')
+  expect(channel!.ownerProfileId).toBe(1)
+  await channelDbProvider.hardDelete(id)
+})
+
+test('getChannelBySlug', async () => {
+  const id = await channelDbProvider.createChannel({
+    ownerProfileId: 1,
+    name: 'Tech',
+    slug: 'tech',
+    description: 'Tech talk'
+  })
+  const channel = await channelDbProvider.getChannelBySlug('tech')
+  expect(channel).not.toBeNull()
+  expect(channel!.name).toBe('Tech')
+  await channelDbProvider.hardDelete(id)
+})
+
+test('updateChannel', async () => {
+  const id = await channelDbProvider.createChannel({
+    ownerProfileId: 1,
+    name: 'Old Name',
+    slug: 'old-name',
+    description: 'Old description'
+  })
+  await channelDbProvider.updateChannel(id, { name: 'New Name', slug: 'new-name', description: 'New description' })
+  const channel = await channelDbProvider.getChannelById(id)
+  expect(channel!.name).toBe('New Name')
+  expect(channel!.slug).toBe('new-name')
+  await channelDbProvider.hardDelete(id)
+})
+
+test('listChannels', async () => {
+  const id = await channelDbProvider.createChannel({
+    ownerProfileId: 1,
+    name: 'Listed',
+    slug: 'listed',
+    description: 'A listed channel'
+  })
+  const channels = await channelDbProvider.listChannels()
+  expect(channels.some((c) => c.name === 'Listed')).toBe(true)
+  await channelDbProvider.hardDelete(id)
+})
+
+test('addModerator, listModeratorProfiles, removeModerator', async () => {
+  const id = await channelDbProvider.createChannel({
+    ownerProfileId: 1,
+    name: 'Moderated',
+    slug: 'moderated',
+    description: 'A moderated channel'
+  })
+
+  await channelDbProvider.addModerator(id, 2)
+  const mods = await channelDbProvider.listModeratorProfiles(id)
+  expect(mods).toHaveLength(1)
+  expect(mods[0]!.profileId).toBe(2)
+
+  await channelDbProvider.removeModerator(id, 2)
+  const modsAfter = await channelDbProvider.listModeratorProfiles(id)
+  expect(modsAfter).toHaveLength(0)
+
+  await channelDbProvider.hardDelete(id)
+})

package/skills/maestro-examples/references/chorus/packages/services/src/channel/channel-db-provider.ts

@@ -0,0 +1,158 @@
+import { Db } from '@maestro-js/db'
+import { ChannelSchemas } from '@chorus/schemas'
+import { instantFns } from 'iso-fns'
+
+type Channel = ChannelSchemas.channelModel
+
+async function createChannel(data: {
+  ownerProfileId: number
+  name: string
+  slug: string
+  description: string
+}): Promise<number> {
+  const now = instantFns.formatISO9075(instantFns.now())
+  const result = await Db.insert(
+    'INSERT INTO channels (ownerProfileId, name, slug, description, createdDate, lastModifiedDate) VALUES (?, ?, ?, ?, ?, ?)',
+    [data.ownerProfileId, data.name, data.slug, data.description, now, now]
+  )
+  return result.insertId
+}
+
+async function getChannelById(id: number): Promise<Channel | null> {
+  const rows = await Db.select(
+    'SELECT channels.*, GROUP_CONCAT(channelModerators.profileId) AS moderatorProfileIdsCsv FROM channels LEFT JOIN channelModerators ON channelModerators.channelId = channels.id WHERE channels.id = ? GROUP BY channels.id',
+    [id]
+  )
+  const row = rows[0]
+  if (!row) return null
+  return parseChannelRow(row)
+}
+
+async function getChannelBySlug(slug: string): Promise<Channel | null> {
+  const rows = await Db.select(
+    'SELECT channels.*, GROUP_CONCAT(channelModerators.profileId) AS moderatorProfileIdsCsv FROM channels LEFT JOIN channelModerators ON channelModerators.channelId = channels.id WHERE channels.slug = ? GROUP BY channels.id',
+    [slug]
+  )
+  const row = rows[0]
+  if (!row) return null
+  return parseChannelRow(row)
+}
+
+async function updateChannel(id: number, data: { name: string; slug: string; description: string }): Promise<void> {
+  const now = instantFns.formatISO9075(instantFns.now())
+  await Db.update('UPDATE channels SET name = ?, slug = ?, description = ?, lastModifiedDate = ? WHERE id = ?', [
+    data.name,
+    data.slug,
+    data.description,
+    now,
+    id
+  ])
+}
+
+async function updateChannelOwner(id: number, newOwnerProfileId: number): Promise<void> {
+  await Db.update('UPDATE channels SET ownerProfileId = ?, lastModifiedDate = ? WHERE id = ?', [
+    newOwnerProfileId,
+    instantFns.formatISO9075(instantFns.now()),
+    id
+  ])
+}
+
+async function listChannels(): Promise<Channel[]> {
+  const rows = await Db.select(
+    'SELECT channels.*, GROUP_CONCAT(channelModerators.profileId) AS moderatorProfileIdsCsv FROM channels LEFT JOIN channelModerators ON channelModerators.channelId = channels.id GROUP BY channels.id'
+  )
+  return rows.map(parseChannelRow)
+}
+
+async function listChannelsWithActivity(): Promise<(Channel & { activityCount: number })[]> {
+  const twentyFourHoursAgo = instantFns.formatISO9075(instantFns.subtract(instantFns.now(), { hours: 24 }))
+  const rows = await Db.select(
+    `WITH activity AS (
+  SELECT posts.channelId, COUNT(*) AS cnt
+  FROM posts
+  WHERE posts.createdDate >= ?
+  GROUP BY posts.channelId
+  UNION ALL
+  SELECT posts.channelId, COUNT(*) AS cnt
+  FROM likes
+  JOIN posts ON likes.postId = posts.id
+  WHERE likes.createdDate >= ?
+  GROUP BY posts.channelId
+)
+SELECT channels.*, COALESCE(SUM(activity.cnt), 0) AS activityCount, GROUP_CONCAT(channelModerators.profileId) AS moderatorProfileIdsCsv
+FROM channels
+LEFT JOIN activity ON activity.channelId = channels.id
+LEFT JOIN channelModerators ON channelModerators.channelId = channels.id
+GROUP BY channels.id
+ORDER BY activityCount DESC, channels.createdDate DESC`,
+    [twentyFourHoursAgo, twentyFourHoursAgo]
+  )
+  return rows.map((row) => {
+    const channel = parseChannelRow(row)
+    return { ...channel, activityCount: Number((row as Record<string, unknown>).activityCount) }
+  })
+}
+
+function parseChannelRow(row: unknown): Channel {
+  const r = row as Record<string, unknown>
+  const csv = r.moderatorProfileIdsCsv as string | null
+  const moderatorProfileIds = csv ? csv.split(',').map(Number) : []
+  return ChannelSchemas.channelModel.parse({
+    ...r,
+    moderatorProfileIds
+  })
+}
+
+async function listModeratorProfiles(
+  channelId: number
+): Promise<{ profileId: number; username: string | null; profileImage: string | null }[]> {
+  return Db.select<{ profileId: number; username: string | null; profileImage: string | null }>(
+    `SELECT profiles.profileId, profiles.username, profiles.profileImage
+FROM channelModerators
+JOIN profiles ON profiles.profileId = channelModerators.profileId
+WHERE channelModerators.channelId = ?`,
+    [channelId]
+  )
+}
+
+async function addModerator(channelId: number, profileId: number): Promise<void> {
+  await Db.insert('INSERT IGNORE INTO channelModerators (channelId, profileId) VALUES (?, ?)', [channelId, profileId])
+}
+
+async function removeModerator(channelId: number, profileId: number): Promise<void> {
+  await Db.delete('DELETE FROM channelModerators WHERE channelId = ? AND profileId = ?', [channelId, profileId])
+}
+
+async function seedCreate(data: Omit<ChannelSchemas.channelModel, 'moderatorProfileIds'>): Promise<void> {
+  await Db.insert(
+    'INSERT INTO channels (id, ownerProfileId, name, slug, description, createdDate, lastModifiedDate) VALUES (?, ?, ?, ?, ?, ?, ?)',
+    [
+      data.id,
+      data.ownerProfileId,
+      data.name,
+      data.slug,
+      data.description,
+      instantFns.formatISO9075(data.createdDate),
+      instantFns.formatISO9075(data.lastModifiedDate)
+    ]
+  )
+}
+
+async function hardDelete(id: number): Promise<void> {
+  await Db.delete('DELETE FROM channels WHERE id = ?', [id])
+}
+
+export const channelDbProvider = {
+  createChannel,
+  getChannelById,
+  getChannelBySlug,
+  updateChannel,
+  updateChannelOwner,
+  listChannels,
+  listChannelsWithActivity,
+  listModeratorProfiles,
+  addModerator,
+  removeModerator,
+  seedCreate,
+  hardDelete
+}