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

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

@@ -0,0 +1,303 @@
+import z from 'zod'
+import crypto from 'node:crypto'
+import { ChannelSchemas, ProfileSchemas } from '@chorus/schemas'
+import { CustomErrors } from '@maestro-js/custom-errors'
+import { Permissions } from '@maestro-js/permissions'
+import { Db } from '@maestro-js/db'
+import { Cache } from '@maestro-js/cache'
+import { Log } from '@maestro-js/log'
+import { channelDbProvider } from './channel-db-provider.ts'
+import { postDbProvider } from '../post/post-db-provider.ts'
+import { likeDbProvider } from '../like/like-db-provider.ts'
+import { profileDbProvider } from '../profile/profile-db-provider.ts'
+
+const isTesting = process.env.IS_TESTING === 'true'
+
+export const BrowseChannels = z
+  .function({
+    input: [z.void()]
+  })
+  .implement(async () => {
+    if (isTesting) {
+      return channelDbProvider.listChannelsWithActivity()
+    }
+    return Cache.remember('channels:browse:activity', '2 minutes', async () => {
+      return channelDbProvider.listChannelsWithActivity()
+    })
+  })
+
+export const CreateChannel = z
+  .function({
+    input: [ChannelSchemas.createChannelSchema, ProfileSchemas.Profile]
+  })
+  .implement(async ({ name, description }, profile) => {
+    const slug = await uniqueSlug(name)
+
+    const channelId = await channelDbProvider.createChannel({
+      ownerProfileId: profile.profileId,
+      name,
+      slug,
+      description
+    })
+
+    Log.info({ channel: 'community', action: 'channel.created', profileId: profile.profileId, channelId, slug })
+
+    return { channelId, slug }
+  })
+
+export const EditChannel = z
+  .function({
+    input: [ChannelSchemas.editChannelSchema.extend({ slug: z.string() }), ProfileSchemas.Profile]
+  })
+  .implement(async ({ slug: currentSlug, name, description }, profile) => {
+    const channel = await channelDbProvider.getChannelBySlug(currentSlug)
+    if (!channel) throw new ChannelNotFoundError()
+
+    if (channel.ownerProfileId !== profile.profileId) {
+      Log.warn({
+        channel: 'community',
+        action: 'channel.edit.denied',
+        profileId: profile.profileId,
+        channelId: channel.id,
+        reason: 'not_authorized'
+      })
+      throw new Permissions.PermissionsError({ action: 'edit', subject: 'channel' })
+    }
+
+    const newSlug = name !== channel.name ? await uniqueSlug(name) : channel.slug
+
+    await channelDbProvider.updateChannel(channel.id, { name, slug: newSlug, description })
+
+    Log.info({ channel: 'community', action: 'channel.edited', profileId: profile.profileId, channelId: channel.id })
+
+    return { slug: newSlug }
+  })
+
+export const AppointModerator = z
+  .function({
+    input: [
+      z.object({
+        slug: z.string(),
+        username: z.string()
+      }),
+      ProfileSchemas.Profile
+    ]
+  })
+  .implement(async ({ slug, username }, profile) => {
+    const channel = await channelDbProvider.getChannelBySlug(slug)
+    if (!channel) throw new ChannelNotFoundError()
+
+    if (channel.ownerProfileId !== profile.profileId) {
+      Log.warn({
+        channel: 'community',
+        action: 'channel.appointModerator.denied',
+        profileId: profile.profileId,
+        channelId: channel.id,
+        reason: 'not_authorized'
+      })
+      throw new Permissions.PermissionsError({ action: 'appointModerator', subject: 'channel' })
+    }
+
+    const targetProfile = await profileDbProvider.getProfileByUsername(username)
+    if (!targetProfile) throw new UserNotFoundError()
+
+    if (targetProfile.profileId === channel.ownerProfileId) return
+
+    await channelDbProvider.addModerator(channel.id, targetProfile.profileId)
+
+    Log.info({
+      channel: 'community',
+      action: 'channel.moderatorAppointed',
+      profileId: profile.profileId,
+      channelId: channel.id,
+      moderatorProfileId: targetProfile.profileId
+    })
+  })
+
+export const RemoveModerator = z
+  .function({
+    input: [
+      z.object({
+        slug: z.string(),
+        username: z.string()
+      }),
+      ProfileSchemas.Profile
+    ]
+  })
+  .implement(async ({ slug, username }, profile) => {
+    const channel = await channelDbProvider.getChannelBySlug(slug)
+    if (!channel) throw new ChannelNotFoundError()
+
+    if (channel.ownerProfileId !== profile.profileId) {
+      Log.warn({
+        channel: 'community',
+        action: 'channel.removeModerator.denied',
+        profileId: profile.profileId,
+        channelId: channel.id,
+        reason: 'not_authorized'
+      })
+      throw new Permissions.PermissionsError({ action: 'removeModerator', subject: 'channel' })
+    }
+
+    const targetProfile = await profileDbProvider.getProfileByUsername(username)
+    if (!targetProfile) throw new UserNotFoundError()
+
+    await channelDbProvider.removeModerator(channel.id, targetProfile.profileId)
+
+    Log.info({
+      channel: 'community',
+      action: 'channel.moderatorRemoved',
+      profileId: profile.profileId,
+      channelId: channel.id,
+      moderatorProfileId: targetProfile.profileId
+    })
+  })
+
+export const TransferOwnership = z
+  .function({
+    input: [
+      z.object({
+        slug: z.string(),
+        username: z.string()
+      }),
+      ProfileSchemas.Profile
+    ]
+  })
+  .implement(async ({ slug, username }, profile) => {
+    const channel = await channelDbProvider.getChannelBySlug(slug)
+    if (!channel) throw new ChannelNotFoundError()
+
+    if (channel.ownerProfileId !== profile.profileId) {
+      Log.warn({
+        channel: 'community',
+        action: 'channel.transferOwnership.denied',
+        profileId: profile.profileId,
+        channelId: channel.id,
+        reason: 'not_authorized'
+      })
+      throw new Permissions.PermissionsError({ action: 'transferOwnership', subject: 'channel' })
+    }
+
+    const targetProfile = await profileDbProvider.getProfileByUsername(username)
+    if (!targetProfile) throw new UserNotFoundError()
+
+    await Db.transaction(async () => {
+      await channelDbProvider.updateChannelOwner(channel.id, targetProfile.profileId)
+      // Remove new owner from moderators if they were one (owner != moderator)
+      await channelDbProvider.removeModerator(channel.id, targetProfile.profileId)
+    })
+
+    Log.info({
+      channel: 'community',
+      action: 'channel.ownershipTransferred',
+      profileId: profile.profileId,
+      channelId: channel.id,
+      newOwnerProfileId: targetProfile.profileId
+    })
+  })
+
+export const GetChannel = z
+  .function({
+    input: [z.object({ slug: z.string() })]
+  })
+  .implement(async ({ slug }) => {
+    const channel = await channelDbProvider.getChannelBySlug(slug)
+    if (!channel) throw new ChannelNotFoundError()
+    return channel
+  })
+
+export const ListChannelModerators = z
+  .function({
+    input: [z.object({ slug: z.string() }), ProfileSchemas.Profile]
+  })
+  .implement(async ({ slug }, profile) => {
+    const channel = await channelDbProvider.getChannelBySlug(slug)
+    if (!channel) throw new ChannelNotFoundError()
+    if (channel.ownerProfileId !== profile.profileId) {
+      throw new Permissions.PermissionsError({ action: 'manage', subject: 'channel' })
+    }
+    const moderatorProfiles = await channelDbProvider.listModeratorProfiles(channel.id)
+    return moderatorProfiles
+  })
+
+export const ViewChannelPosts = z
+  .function({
+    input: [
+      z.object({
+        slug: z.string(),
+        page: z.number().int().min(1).default(1)
+      }),
+      ProfileSchemas.Profile.nullable()
+    ]
+  })
+  .implement(async ({ slug, page }, profile) => {
+    const pageSize = 20
+    const offset = (page - 1) * pageSize
+    function fetchData() {
+      const channel = channelDbProvider.getChannelBySlug(slug).then((channel) => {
+        if (!channel) throw new ChannelNotFoundError()
+        else return channel
+      })
+      const postsRaw = postDbProvider.listPostsByChannelSlug(slug, { limit: pageSize, offset })
+
+      const totalCount = postDbProvider.countPostsByChannelSlug(slug)
+
+      const likedByUser = profile
+        ? postsRaw.then((posts) =>
+            likeDbProvider.batchHasLiked(
+              posts.map((p) => p.id),
+              profile.profileId
+            )
+          )
+        : new Set<number>()
+
+      const posts = Promise.all([postsRaw, likedByUser]).then(([postsRaw, likedByUser]) => {
+        return postsRaw.map((post) => ({
+          ...post,
+          likedByCurrentUser: likedByUser.has(post.id)
+        }))
+      })
+
+      return { channel, posts, totalCount }
+    }
+    const promises = fetchData()
+
+    const totalCount = await promises.totalCount
+
+    return {
+      channel: await promises.channel,
+      posts: await promises.posts,
+      pagination: {
+        page,
+        pageSize,
+        totalCount,
+        totalPages: Math.ceil(totalCount / pageSize)
+      }
+    }
+  })
+
+export const ChannelNotFoundError = CustomErrors.create({
+  name: 'ChannelNotFound',
+  message: 'Channel not found'
+})
+
+export const UserNotFoundError = CustomErrors.create({
+  name: 'UserNotFound',
+  message: 'User not found'
+})
+
+const generateSlug = (name: string) =>
+  name
+    .toLowerCase()
+    .replace(/[^a-z0-9\s-]/g, '')
+    .replace(/[\s]+/g, '-')
+    .replace(/-{2,}/g, '-')
+    .replace(/^-+|-+$/g, '')
+
+const randomSuffix = () => crypto.randomBytes(2).toString('hex')
+
+const uniqueSlug = async (name: string) => {
+  const slug = generateSlug(name)
+  const existing = await channelDbProvider.getChannelBySlug(slug)
+  return existing ? `${slug}-${randomSuffix()}` : slug
+}

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

@@ -0,0 +1,29 @@
+import {
+  CreateChannel,
+  EditChannel,
+  BrowseChannels,
+  ViewChannelPosts,
+  AppointModerator,
+  RemoveModerator,
+  TransferOwnership,
+  GetChannel,
+  ListChannelModerators,
+  ChannelNotFoundError,
+  UserNotFoundError
+} from './channel-use-cases.ts'
+
+export const ChannelService = {
+  CreateChannel,
+  EditChannel,
+  BrowseChannels,
+  ViewChannelPosts,
+  AppointModerator,
+  RemoveModerator,
+  TransferOwnership,
+  GetChannel,
+  ListChannelModerators,
+  errors: {
+    ChannelNotFoundError,
+    UserNotFoundError
+  }
+}

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

@@ -0,0 +1,21 @@
+import './maestro.ts'
+export { Db } from '@maestro-js/db'
+export { Cache } from '@maestro-js/cache'
+export { Hash } from '@maestro-js/hash'
+export { Crypt } from '@maestro-js/crypt'
+export { Auth } from '@maestro-js/auth'
+export { Password } from '@maestro-js/password'
+export { AuthService } from './auth/index.ts'
+export { ChannelService } from './channel/index.ts'
+export { PostService } from './post/index.ts'
+export { ProfileService } from './profile/index.ts'
+export { LikeService } from './like/index.ts'
+export { Helpers } from '@maestro-js/helpers'
+export { Session } from '@maestro-js/session'
+export { RateLimiting } from '@maestro-js/rate-limiting'
+export { Queue } from '@maestro-js/queue'
+export { RecurringJobs } from '@maestro-js/recurring-jobs'
+export { SignedUrl } from '@maestro-js/signed-url'
+export { FileStorage } from '@maestro-js/file-storage'
+export { Log } from '@maestro-js/log'
+export { H } from './testing/index.ts'

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

@@ -0,0 +1,6 @@
+import { Like, Unlike } from './like-use-cases.ts'
+
+export const LikeService = {
+  Like,
+  Unlike
+}

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

@@ -0,0 +1,47 @@
+import { test } from 'beartest-js'
+import { expect } from 'expect'
+import { H } from '../testing/index.ts'
+import { likeDbProvider } from './like-db-provider.ts'
+import { postDbProvider } from '../post/post-db-provider.ts'
+
+const profile = H.ProfileSeed({ profileId: 1 })
+const profile2 = H.ProfileSeed({ profileId: 2, username: 'liker', email: 'liker@test.com' })
+const channel = H.ChannelSeed({ id: 1, ownerProfileId: 1 })
+const pipe = H.SeedPipe(profile, profile2, channel)
+
+const createdPostIds: number[] = []
+
+test.beforeEach(async () => { await pipe.setup() })
+test.afterEach(async () => {
+  for (const id of createdPostIds) {
+    await postDbProvider.hardDelete(id)
+  }
+  createdPostIds.length = 0
+  await pipe.teardown()
+})
+
+test('addLike and hasLiked', async () => {
+  const postId = await postDbProvider.createPost({ channelId: 1, profileId: 1, content: 'Likeable post' })
+  createdPostIds.push(postId)
+  expect(await likeDbProvider.hasLiked(postId, 2)).toBe(false)
+  await likeDbProvider.addLike(postId, 2)
+  expect(await likeDbProvider.hasLiked(postId, 2)).toBe(true)
+})
+
+test('removeLike', async () => {
+  const postId = await postDbProvider.createPost({ channelId: 1, profileId: 1, content: 'Unlike post' })
+  createdPostIds.push(postId)
+  await likeDbProvider.addLike(postId, 2)
+  await likeDbProvider.removeLike(postId, 2)
+  expect(await likeDbProvider.hasLiked(postId, 2)).toBe(false)
+})
+
+test('batchHasLiked', async () => {
+  const postId1 = await postDbProvider.createPost({ channelId: 1, profileId: 1, content: 'Batch post 1' })
+  const postId2 = await postDbProvider.createPost({ channelId: 1, profileId: 1, content: 'Batch post 2' })
+  createdPostIds.push(postId1, postId2)
+  await likeDbProvider.addLike(postId1, 2)
+  const liked = await likeDbProvider.batchHasLiked([postId1, postId2], 2)
+  expect(liked.has(postId1)).toBe(true)
+  expect(liked.has(postId2)).toBe(false)
+})

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

@@ -0,0 +1,53 @@
+import { Cache } from '@maestro-js/cache'
+import { Db } from '@maestro-js/db'
+import { LikeSchemas } from '@chorus/schemas'
+import { instantFns } from 'iso-fns'
+
+async function addLike(postId: number, profileId: number): Promise<void> {
+  await Db.insert('INSERT IGNORE INTO likes (postId, profileId, createdDate) VALUES (?, ?, ?)', [
+    postId,
+    profileId,
+    instantFns.formatISO9075(instantFns.now())
+  ])
+}
+
+async function removeLike(postId: number, profileId: number): Promise<void> {
+  await Db.delete('DELETE FROM likes WHERE postId = ? AND profileId = ?', [postId, profileId])
+}
+
+async function hasLiked(postId: number, profileId: number): Promise<boolean> {
+  const rows = await Db.select('SELECT 1 FROM likes WHERE postId = ? AND profileId = ? LIMIT 1', [postId, profileId])
+  return rows.length > 0
+}
+
+async function batchHasLiked(postIds: number[], profileId: number): Promise<Set<number>> {
+  if (postIds.length === 0) return new Set()
+
+  const placeholders = postIds.map(() => '?').join(', ')
+  const rows = await Db.select<{ postId: number }>(
+    `SELECT postId FROM likes WHERE postId IN (${placeholders}) AND profileId = ?`,
+    [...postIds, profileId]
+  )
+  return new Set(rows.map((r) => r.postId))
+}
+
+async function seedCreate(data: LikeSchemas.likeModel): Promise<void> {
+  await Db.insert('INSERT INTO likes (postId, profileId, createdDate) VALUES (?, ?, ?)', [
+    data.postId,
+    data.profileId,
+    instantFns.formatISO9075(data.createdDate)
+  ])
+}
+
+async function hardDelete(postId: number, profileId: number): Promise<void> {
+  await Db.delete('DELETE FROM likes WHERE postId = ? AND profileId = ?', [postId, profileId])
+}
+
+export const likeDbProvider = {
+  addLike,
+  removeLike,
+  hasLiked,
+  batchHasLiked,
+  seedCreate,
+  hardDelete
+}

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

@@ -0,0 +1,31 @@
+import { Cache } from '@maestro-js/cache'
+import { Log } from '@maestro-js/log'
+import { ProfileSchemas } from '@chorus/schemas'
+import z from 'zod'
+import { likeDbProvider } from './like-db-provider.ts'
+
+export const Like = z
+  .function({
+    input: [z.object({ postId: z.number() }), ProfileSchemas.Profile]
+  })
+  .implement(async ({ postId }, profile) => {
+    const alreadyLiked = await likeDbProvider.hasLiked(postId, profile.profileId)
+    if (alreadyLiked) return
+
+    await likeDbProvider.addLike(postId, profile.profileId)
+
+    Log.info({ channel: 'community', action: 'post.liked', profileId: profile.profileId, postId })
+  })
+
+export const Unlike = z
+  .function({
+    input: [z.object({ postId: z.number() }), ProfileSchemas.Profile]
+  })
+  .implement(async ({ postId }, profile) => {
+    const alreadyLiked = await likeDbProvider.hasLiked(postId, profile.profileId)
+    if (!alreadyLiked) return
+
+    await likeDbProvider.removeLike(postId, profile.profileId)
+
+    Log.info({ channel: 'community', action: 'post.unliked', profileId: profile.profileId, postId })
+  })