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

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

@@ -0,0 +1,215 @@
+import { Db } from '@maestro-js/db'
+import { Cache } from '@maestro-js/cache'
+import { Hash } from '@maestro-js/hash'
+import { Crypt } from '@maestro-js/crypt'
+import { Auth } from '@maestro-js/auth'
+import { Password, PasswordReset } from '@maestro-js/password'
+import { authenticatableDbProvider } from './auth/authenticatable-db-provider.ts'
+import { rememberMeTokenDbProvider } from './auth/remember-me-token-db-provider.ts'
+import { passwordResetTokenDbProvider } from './auth/password-reset-token-db-provider.ts'
+import { Session } from '@maestro-js/session'
+import { RateLimiting } from '@maestro-js/rate-limiting'
+import { SignedUrl } from '@maestro-js/signed-url'
+import type { Helpers } from '@maestro-js/helpers'
+import { Mail } from '@maestro-js/mail'
+import { SendRawEmailCommand, SESClient, type SendRawEmailCommandInput } from '@aws-sdk/client-ses'
+import { Queue } from '@maestro-js/queue'
+import { RecurringJobs } from '@maestro-js/recurring-jobs'
+import { Log } from '@maestro-js/log'
+import { Permissions } from '@maestro-js/permissions'
+import { permissionsDriver } from './permissions.ts'
+import type { ActionMap } from './permissions.ts'
+import { FileStorage } from '@maestro-js/file-storage'
+import { S3Client } from '@aws-sdk/client-s3'
+import type { ProfileSchemas } from '@chorus/schemas'
+
+Db.Provider.register(
+  'default',
+  Db.Provider.create({
+    driver: Db.drivers.mysql({
+      user: process.env.DB_USER!,
+      password: process.env.DB_PASSWORD!,
+      host: process.env.DB_HOSTNAME!,
+      database: process.env.DB_DATABASE!,
+      port: Number(process.env.DB_PORT)
+    })
+  })
+)
+
+Cache.Provider.register(
+  'default',
+  Cache.Provider.create({
+    driver: Cache.drivers.mockRedis({})
+  })
+)
+
+Crypt.Provider.register(
+  'default',
+  Crypt.Provider.create({
+    key: process.env.CRYPT_KEY!,
+    previousKeys: []
+  })
+)
+
+Hash.Provider.register(
+  'default',
+  Hash.Provider.create(Hash.drivers.sha256({ key: process.env.HASH_KEY!, previousKeys: [] }))
+)
+Hash.Provider.register('bcrypt', Hash.Provider.create(Hash.drivers.bcrypt({ rounds: 12 })))
+
+type Credentials = {
+  password: string
+  email: string
+}
+export type DeviceContext = ReturnType<(typeof Helpers)['getDeviceContext']>
+
+Password.Provider.register(
+  'default',
+  Password.Provider.create<number, Credentials>({
+    getAuthenticatableByCredentials: authenticatableDbProvider.getAuthenticatableByCredentials,
+    updatePasswordHash: authenticatableDbProvider.updatePasswordHash,
+    updateCredentialsInvalidBefore: authenticatableDbProvider.updateCredentialsInvalidBefore,
+    hash: Hash.provider('bcrypt'),
+    passwordReset: PasswordReset.create<number>({
+      ...passwordResetTokenDbProvider,
+      hash: Hash.provider('bcrypt')
+    })
+  })
+)
+
+Auth.Provider.register(
+  'default',
+  Auth.Provider.create<number, Credentials, DeviceContext>({
+    name: 'default',
+    getAuthenticatableById: authenticatableDbProvider.getAuthenticatableById,
+    verifyCredentials: Password.verifyCredentials,
+    updateCredentialsInvalidBefore: authenticatableDbProvider.updateCredentialsInvalidBefore,
+    hash: Hash,
+    crypt: Crypt,
+    rememberMeOptions: {
+      maxRememberMeSeconds: 60 * 60 * 24 * 30 /* thirty days */,
+      ...rememberMeTokenDbProvider
+    }
+  })
+)
+
+Session.Provider.register(
+  'default',
+  Session.Provider.create({
+    driver: Session.drivers.store({ store: Cache, crypt: Crypt, cookie: { secure: process.env.ENV_NAME !== 'local' } })
+  })
+)
+
+RateLimiting.Provider.register('default', RateLimiting.Provider.create(Cache))
+
+Queue.Provider.register(
+  'default',
+  Queue.Provider.create({
+    driver: Queue.drivers.db({
+      db: Db,
+      databaseTable: 'queueMessages'
+    }),
+    logger: Log
+  })
+)
+
+RecurringJobs.Provider.register(
+  'default',
+  RecurringJobs.Provider.create({
+    driver: RecurringJobs.drivers.db({
+      db: Db,
+      databaseTable: 'recurringJobs'
+    }),
+    logger: Log
+  })
+)
+
+SignedUrl.Provider.register('default', SignedUrl.Provider.create({ driver: Hash.provider('default') }))
+
+Permissions.Provider.register('default', Permissions.Provider.create({ driver: permissionsDriver }))
+
+FileStorage.Provider.register(
+  'default',
+  FileStorage.Provider.create({
+    driver:
+      process.env.ENV_NAME === 'local'
+        ? FileStorage.drivers.local({ pathPrefix: './storage', urlPrefix: '/files' })
+        : FileStorage.drivers.s3({
+            client: new S3Client({ region: process.env.AWS_REGION! }),
+            bucket: process.env.S3_BUCKET!
+          })
+  })
+)
+
+const sesClient = new SESClient({ region: process.env.AWS_REGION })
+
+Mail.Provider.register(
+  'default',
+  Mail.Provider.create({
+    queue: Queue,
+    driver: Mail.drivers.ses({
+      send(command: { input: SendRawEmailCommandInput }) {
+        return sesClient.send(new SendRawEmailCommand(command.input))
+      },
+      configurationSetName: 'sandbox'
+    }),
+    name: 'default',
+    globalFrom: 'maestro@marcatopartners.com',
+    logger: Log
+  })
+)
+
+declare module '@maestro-js/password' {
+  namespace Password {
+    namespace Provider {
+      interface Keys {
+        default: { Id: number; Credentials: Credentials }
+      }
+    }
+  }
+}
+
+declare module '@maestro-js/auth' {
+  namespace Auth {
+    namespace Provider {
+      interface Keys {
+        default: {
+          Credentials: Credentials
+          DeviceContext: DeviceContext
+          Id: number
+        }
+      }
+    }
+  }
+}
+
+declare module '@maestro-js/hash' {
+  namespace Hash {
+    namespace Provider {
+      interface Keys {
+        default: true
+        bcrypt: true
+      }
+    }
+  }
+}
+
+declare module '@maestro-js/permissions' {
+  namespace Permissions {
+    namespace Provider {
+      interface Keys {
+        default: { ActionMap: ActionMap; Profile: ProfileSchemas.Profile | null }
+      }
+    }
+  }
+}
+
+declare module '@maestro-js/file-storage' {
+  namespace FileStorage {
+    namespace Provider {
+      interface Keys {
+        default: true
+      }
+    }
+  }
+}

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

@@ -0,0 +1,16 @@
+import { Permissions } from '@maestro-js/permissions'
+import type { ProfileSchemas } from '@chorus/schemas'
+
+export type ActionMap = {
+  channel: ['create', 'edit', 'appointModerator', 'removeModerator', 'transferOwnership']
+  post: ['create', 'createReply', 'hide', 'uploadImage']
+  like: ['like', 'unlike']
+}
+
+export const permissionsDriver = Permissions.drivers.static<ActionMap, ProfileSchemas.Profile | null>((profile, allow) => {
+  if (profile) {
+    allow('channel', ['create', 'edit', 'appointModerator', 'removeModerator', 'transferOwnership'])
+    allow('post', ['create', 'createReply', 'hide', 'uploadImage'])
+    allow('like', ['like', 'unlike'])
+  }
+})

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

@@ -0,0 +1,25 @@
+import {
+  CreatePost,
+  CreateReply,
+  ViewPost,
+  HidePost,
+  UploadImage,
+  PostNotFoundError,
+  CannotReplyToReplyError,
+  InvalidImageTypeError,
+  ImageTooLargeError
+} from './post-use-cases.ts'
+
+export const PostService = {
+  CreatePost,
+  CreateReply,
+  ViewPost,
+  HidePost,
+  UploadImage,
+  errors: {
+    PostNotFoundError,
+    CannotReplyToReplyError,
+    InvalidImageTypeError,
+    ImageTooLargeError
+  }
+}

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

@@ -0,0 +1,68 @@
+import { test } from 'beartest-js'
+import { expect } from 'expect'
+import { H } from '../testing/index.ts'
+import { postDbProvider } from './post-db-provider.ts'
+
+const profile = H.ProfileSeed({ profileId: 1 })
+const channel = H.ChannelSeed({ id: 1, ownerProfileId: 1 })
+const pipe = H.SeedPipe(profile, channel)
+
+test.beforeEach(async () => { await pipe.setup() })
+test.afterEach(async () => { await pipe.teardown() })
+
+test('createPost and getPostById', async () => {
+  const id = await postDbProvider.createPost({ channelId: 1, profileId: 1, content: 'Hello world' })
+  const post = await postDbProvider.getPostById(id)
+  expect(post).not.toBeNull()
+  expect(post!.content).toBe('Hello world')
+  expect(post!.channelId).toBe(1)
+  expect(post!.profileId).toBe(1)
+  expect(post!.replyingToPostId).toBeNull()
+  await postDbProvider.hardDelete(id)
+})
+
+test('listPostsByChannelId', async () => {
+  const id = await postDbProvider.createPost({ channelId: 1, profileId: 1, content: 'Post in channel' })
+  const posts = await postDbProvider.listPostsByChannelId(1, { limit: 10, offset: 0 })
+  expect(posts.some((p) => p.content === 'Post in channel')).toBe(true)
+  await postDbProvider.hardDelete(id)
+})
+
+test('countPostsByChannel', async () => {
+  const id = await postDbProvider.createPost({ channelId: 1, profileId: 1, content: 'Counted post' })
+  const count = await postDbProvider.countPostsByChannel(1)
+  expect(count).toBeGreaterThanOrEqual(1)
+  await postDbProvider.hardDelete(id)
+})
+
+test('hidePost', async () => {
+  const id = await postDbProvider.createPost({ channelId: 1, profileId: 1, content: 'To be hidden' })
+  await postDbProvider.hidePost(id)
+  const post = await postDbProvider.getPostById(id)
+  expect(post!.hiddenDate).not.toBeNull()
+  await postDbProvider.hardDelete(id)
+})
+
+test('insertImages and getImagesByPostId', async () => {
+  const id = await postDbProvider.createPost({ channelId: 1, profileId: 1, content: 'Post with images' })
+  await postDbProvider.insertImages(id, ['https://example.com/a.png', 'https://example.com/b.png'])
+  const images = await postDbProvider.getImagesByPostId(id)
+  expect(images).toHaveLength(2)
+  expect(images[0]).toBe('https://example.com/a.png')
+  expect(images[1]).toBe('https://example.com/b.png')
+  await postDbProvider.hardDelete(id)
+})
+
+test('isReply', async () => {
+  const parentId = await postDbProvider.createPost({ channelId: 1, profileId: 1, content: 'Parent post' })
+  const replyId = await postDbProvider.createPost({
+    channelId: 1,
+    profileId: 1,
+    content: 'Reply post',
+    replyingToPostId: parentId
+  })
+  expect(await postDbProvider.isReply(parentId)).toBe(false)
+  expect(await postDbProvider.isReply(replyId)).toBe(true)
+  await postDbProvider.hardDelete(replyId)
+  await postDbProvider.hardDelete(parentId)
+})

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

@@ -0,0 +1,219 @@
+import { Db } from '@maestro-js/db'
+import { PostSchemas } from '@chorus/schemas'
+import { instantFns } from 'iso-fns'
+
+type Post = Omit<PostSchemas.postSystemView, 'likedByCurrentUser'>
+
+const postWithoutLiked = PostSchemas.postSystemView.omit({ likedByCurrentUser: true })
+
+const POST_SELECT = `WITH
+  likeCounts AS (
+    SELECT postId, COUNT(*) AS likeCount
+    FROM likes
+    GROUP BY postId
+  ),
+  replyCounts AS (
+    SELECT replyingToPostId, COUNT(*) AS replyCount
+    FROM posts
+    WHERE replyingToPostId IS NOT NULL AND hiddenDate IS NULL
+    GROUP BY replyingToPostId
+  )
+SELECT
+  posts.*,
+  profiles.username AS authorUsername,
+  profiles.profileImage AS authorProfileImage,
+  postImages.url,
+  postImages.sortOrder,
+  COALESCE(likeCounts.likeCount, 0) AS likeCount,
+  COALESCE(replyCounts.replyCount, 0) AS replyCount
+FROM
+  posts
+  JOIN profiles ON profiles.profileId = posts.profileId
+  LEFT JOIN postImages ON postImages.postId = posts.id
+  LEFT JOIN likeCounts ON likeCounts.postId = posts.id
+  LEFT JOIN replyCounts ON replyCounts.replyingToPostId = posts.id`
+
+async function createPost(data: {
+  channelId: number
+  profileId: number
+  content: string
+  replyingToPostId?: number
+}): Promise<number> {
+  const now = instantFns.formatISO9075(instantFns.now())
+  const result = await Db.insert(
+    'INSERT INTO posts (channelId, profileId, replyingToPostId, content, createdDate, lastModifiedDate) VALUES (?, ?, ?, ?, ?, ?)',
+    [data.channelId, data.profileId, data.replyingToPostId ?? null, data.content, now, now]
+  )
+  return result.insertId
+}
+
+async function getPostById(id: number): Promise<Post | null> {
+  const rows = await Db.select(
+    `${POST_SELECT}
+WHERE posts.id = ?
+ORDER BY postImages.sortOrder ASC`,
+    [id]
+  )
+  if (rows.length === 0) return null
+  return parsePostRows(rows)[0] ?? null
+}
+
+async function listPostsByChannelId(channelId: number, opts: { limit: number; offset: number }): Promise<Post[]> {
+  const rows = await Db.select(
+    `${POST_SELECT}
+WHERE posts.channelId = ? AND posts.replyingToPostId IS NULL AND posts.hiddenDate IS NULL
+ORDER BY posts.createdDate DESC, postImages.sortOrder ASC
+LIMIT ? OFFSET ?`,
+    [channelId, opts.limit, opts.offset]
+  )
+  return parsePostRows(rows)
+}
+
+async function listPostsByChannelSlug(slug: string, opts: { limit: number; offset: number }): Promise<Post[]> {
+  const rows = await Db.select(
+    `${POST_SELECT}
+JOIN channels ON channels.id = posts.channelId
+WHERE channels.slug = ? AND posts.replyingToPostId IS NULL AND posts.hiddenDate IS NULL
+ORDER BY posts.createdDate DESC, postImages.sortOrder ASC
+LIMIT ? OFFSET ?`,
+    [slug, opts.limit, opts.offset]
+  )
+  return parsePostRows(rows)
+}
+
+async function listRepliesByPostId(postId: number): Promise<Post[]> {
+  const rows = await Db.select(
+    `${POST_SELECT}
+WHERE posts.replyingToPostId = ? AND posts.hiddenDate IS NULL
+ORDER BY posts.createdDate ASC, postImages.sortOrder ASC`,
+    [postId]
+  )
+  return parsePostRows(rows)
+}
+
+async function countPostsByChannel(channelId: number): Promise<number> {
+  const count = await Db.scalar<number>(
+    'SELECT COUNT(*) FROM posts WHERE channelId = ? AND replyingToPostId IS NULL AND hiddenDate IS NULL',
+    [channelId]
+  )
+  return count ?? 0
+}
+
+async function countPostsByChannelSlug(slug: string): Promise<number> {
+  const count = await Db.scalar<number>(
+    'SELECT COUNT(*) FROM posts JOIN channels ON channels.id = posts.channelId WHERE channels.slug = ? AND posts.replyingToPostId IS NULL AND posts.hiddenDate IS NULL',
+    [slug]
+  )
+  return count ?? 0
+}
+
+async function hidePost(postId: number): Promise<void> {
+  const now = instantFns.formatISO9075(instantFns.now())
+  await Db.update('UPDATE posts SET hiddenDate = ?, lastModifiedDate = ? WHERE id = ?', [now, now, postId])
+}
+
+async function isReply(postId: number): Promise<boolean> {
+  const replyingToPostId = await Db.scalar<number>('SELECT replyingToPostId FROM posts WHERE id = ?', [postId])
+  return replyingToPostId != null
+}
+
+function parsePostRows(rows: unknown[]): Post[] {
+  const postMap = new Map<number, { row: Record<string, unknown>; images: string[] }>()
+
+  for (const raw of rows) {
+    const r = raw as Record<string, unknown>
+    const id = r.id as number
+
+    if (!postMap.has(id)) {
+      postMap.set(id, { row: r, images: [] })
+    }
+
+    const url = r.url as string | null
+    if (url) {
+      postMap.get(id)!.images.push(url)
+    }
+  }
+
+  const posts: Post[] = []
+  for (const { row, images } of postMap.values()) {
+    posts.push(
+      postWithoutLiked.parse({
+        ...row,
+        images
+      })
+    )
+  }
+  return posts
+}
+
+async function insertImages(postId: number, urls: string[]): Promise<void> {
+  if (urls.length === 0) return
+
+  const placeholders = urls.map(() => '(?, ?, ?)').join(', ')
+  const values = urls.flatMap((url, i) => [postId, i, url])
+
+  await Db.insert(`INSERT INTO postImages (postId, sortOrder, url) VALUES ${placeholders}`, values)
+}
+
+async function getImagesByPostId(postId: number): Promise<string[]> {
+  const rows = await Db.select<{ url: string }>('SELECT url FROM postImages WHERE postId = ? ORDER BY sortOrder ASC', [
+    postId
+  ])
+  return rows.map((r) => r.url)
+}
+
+async function getImagesByPostIds(postIds: number[]): Promise<Map<number, string[]>> {
+  if (postIds.length === 0) return new Map()
+
+  const placeholders = postIds.map(() => '?').join(', ')
+  const rows = await Db.select<{ postId: number; url: string }>(
+    `SELECT postId, url FROM postImages WHERE postId IN (${placeholders}) ORDER BY sortOrder ASC`,
+    postIds
+  )
+
+  const map = new Map<number, string[]>()
+  for (const row of rows) {
+    const existing = map.get(row.postId) ?? []
+    existing.push(row.url)
+    map.set(row.postId, existing)
+  }
+  return map
+}
+
+async function seedCreate(data: Omit<PostSchemas.postModel, 'images'>): Promise<void> {
+  await Db.insert(
+    'INSERT INTO posts (id, channelId, profileId, replyingToPostId, content, hiddenDate, createdDate, lastModifiedDate) VALUES (?, ?, ?, ?, ?, ?, ?, ?)',
+    [
+      data.id,
+      data.channelId,
+      data.profileId,
+      data.replyingToPostId,
+      data.content,
+      data.hiddenDate ? instantFns.formatISO9075(data.hiddenDate) : null,
+      instantFns.formatISO9075(data.createdDate),
+      instantFns.formatISO9075(data.lastModifiedDate)
+    ]
+  )
+}
+
+async function hardDelete(id: number): Promise<void> {
+  await Db.delete('DELETE FROM postImages WHERE postId = ?', [id])
+  await Db.delete('DELETE FROM posts WHERE id = ?', [id])
+}
+
+export const postDbProvider = {
+  createPost,
+  getPostById,
+  listPostsByChannelId,
+  listPostsByChannelSlug,
+  listRepliesByPostId,
+  countPostsByChannel,
+  countPostsByChannelSlug,
+  hidePost,
+  isReply,
+  insertImages,
+  getImagesByPostId,
+  getImagesByPostIds,
+  seedCreate,
+  hardDelete
+}