@primocaredentgroup/chat-backend-component 0.1.0

package/src/component/lib.ts

@@ -0,0 +1,399 @@
+import { v } from 'convex/values'
+import { mutation, query } from './_generated/server.js'
+
+const channelKindValidator = v.union(v.literal('general'), v.literal('custom'))
+
+/**
+ * CHANNEL CRUD
+ */
+export const createChannel = mutation({
+  args: {
+    externalId: v.string(),
+    name: v.string(),
+    metadata: v.optional(v.any())
+  },
+  returns: v.id('channels'),
+  handler: async (ctx, args) => {
+    const now = Date.now()
+    return await ctx.db.insert('channels', {
+      externalId: args.externalId,
+      name: args.name,
+      archived: false,
+      metadata: args.metadata,
+      createdAt: now,
+      updatedAt: now
+    })
+  }
+})
+
+/**
+ * Ensure channel exists for external ID (e.g. patientId),
+ * and auto-create "General" subchannel on first creation.
+ */
+export const getOrCreateChannel = mutation({
+  args: {
+    externalId: v.string(),
+    name: v.string(),
+    metadata: v.optional(v.any())
+  },
+  returns: v.id('channels'),
+  handler: async (ctx, args) => {
+    const existing = await ctx.db
+      .query('channels')
+      .withIndex('by_external_id', (q) => q.eq('externalId', args.externalId))
+      .first()
+
+    if (existing) {
+      if (existing.archived || existing.name !== args.name) {
+        await ctx.db.patch(existing._id, {
+          archived: false,
+          name: args.name,
+          metadata: args.metadata,
+          updatedAt: Date.now()
+        })
+      }
+      return existing._id
+    }
+
+    const now = Date.now()
+    const channelId = await ctx.db.insert('channels', {
+      externalId: args.externalId,
+      name: args.name,
+      archived: false,
+      metadata: args.metadata,
+      createdAt: now,
+      updatedAt: now
+    })
+
+    await ctx.db.insert('subchannels', {
+      channelId,
+      name: 'Generale',
+      kind: 'general',
+      archived: false,
+      createdAt: now,
+      updatedAt: now
+    })
+
+    return channelId
+  }
+})
+
+export const getChannel = query({
+  args: { channelId: v.id('channels') },
+  handler: async (ctx, args) => await ctx.db.get(args.channelId)
+})
+
+export const listChannels = query({
+  args: { includeArchived: v.optional(v.boolean()) },
+  handler: async (ctx, args) => {
+    const channels = await ctx.db.query('channels').collect()
+    if (args.includeArchived) return channels
+    return channels.filter((channel) => !channel.archived)
+  }
+})
+
+export const updateChannel = mutation({
+  args: {
+    channelId: v.id('channels'),
+    name: v.optional(v.string()),
+    metadata: v.optional(v.any())
+  },
+  returns: v.null(),
+  handler: async (ctx, args) => {
+    const patch: {
+      updatedAt: number
+      name?: string
+      metadata?: unknown
+    } = { updatedAt: Date.now() }
+    if (args.name !== undefined) patch.name = args.name
+    if (args.metadata !== undefined) patch.metadata = args.metadata
+    await ctx.db.patch(args.channelId, patch)
+    return null
+  }
+})
+
+export const archiveChannel = mutation({
+  args: {
+    channelId: v.id('channels'),
+    archived: v.optional(v.boolean())
+  },
+  returns: v.null(),
+  handler: async (ctx, args) => {
+    const archived = args.archived ?? true
+    const now = Date.now()
+    await ctx.db.patch(args.channelId, { archived, updatedAt: now })
+
+    const subchannels = await ctx.db
+      .query('subchannels')
+      .withIndex('by_channel', (q) => q.eq('channelId', args.channelId))
+      .collect()
+
+    await Promise.all(
+      subchannels.map((subchannel) =>
+        ctx.db.patch(subchannel._id, { archived, updatedAt: now })
+      )
+    )
+
+    return null
+  }
+})
+
+export const deleteChannel = mutation({
+  args: { channelId: v.id('channels') },
+  returns: v.null(),
+  handler: async (ctx, args) => {
+    const subchannels = await ctx.db
+      .query('subchannels')
+      .withIndex('by_channel', (q) => q.eq('channelId', args.channelId))
+      .collect()
+
+    for (const subchannel of subchannels) {
+      const messages = await ctx.db
+        .query('messages')
+        .withIndex('by_subchannel_and_time', (q) =>
+          q.eq('subchannelId', subchannel._id)
+        )
+        .collect()
+
+      for (const message of messages) {
+        await ctx.db.delete(message._id)
+      }
+
+      await ctx.db.delete(subchannel._id)
+    }
+
+    await ctx.db.delete(args.channelId)
+    return null
+  }
+})
+
+/**
+ * SUBCHANNEL CRUD
+ */
+export const createSubchannel = mutation({
+  args: {
+    channelId: v.id('channels'),
+    name: v.string(),
+    kind: v.optional(channelKindValidator),
+    externalReferenceId: v.optional(v.string()),
+    metadata: v.optional(v.any())
+  },
+  returns: v.id('subchannels'),
+  handler: async (ctx, args) => {
+    const channel = await ctx.db.get(args.channelId)
+    if (!channel) {
+      throw new Error('Channel not found')
+    }
+
+    const now = Date.now()
+    return await ctx.db.insert('subchannels', {
+      channelId: args.channelId,
+      name: args.name,
+      kind: args.kind ?? 'custom',
+      externalReferenceId: args.externalReferenceId,
+      metadata: args.metadata,
+      archived: false,
+      createdAt: now,
+      updatedAt: now
+    })
+  }
+})
+
+export const getOrCreateSubchannel = mutation({
+  args: {
+    channelId: v.id('channels'),
+    name: v.string(),
+    kind: v.optional(channelKindValidator),
+    externalReferenceId: v.string(),
+    metadata: v.optional(v.any())
+  },
+  returns: v.id('subchannels'),
+  handler: async (ctx, args) => {
+    const existing = await ctx.db
+      .query('subchannels')
+      .withIndex('by_channel_and_external_reference', (q) =>
+        q
+          .eq('channelId', args.channelId)
+          .eq('externalReferenceId', args.externalReferenceId)
+      )
+      .first()
+
+    if (existing) {
+      return existing._id
+    }
+
+    const now = Date.now()
+    return await ctx.db.insert('subchannels', {
+      channelId: args.channelId,
+      name: args.name,
+      kind: args.kind ?? 'custom',
+      externalReferenceId: args.externalReferenceId,
+      metadata: args.metadata,
+      archived: false,
+      createdAt: now,
+      updatedAt: now
+    })
+  }
+})
+
+export const getSubchannel = query({
+  args: { subchannelId: v.id('subchannels') },
+  handler: async (ctx, args) => await ctx.db.get(args.subchannelId)
+})
+
+export const listSubchannels = query({
+  args: {
+    channelId: v.id('channels'),
+    includeArchived: v.optional(v.boolean())
+  },
+  handler: async (ctx, args) => {
+    const subchannels = await ctx.db
+      .query('subchannels')
+      .withIndex('by_channel', (q) => q.eq('channelId', args.channelId))
+      .collect()
+
+    const visible = args.includeArchived
+      ? subchannels
+      : subchannels.filter((subchannel) => !subchannel.archived)
+
+    return visible.sort((a, b) => {
+      if (a.kind === 'general' && b.kind !== 'general') return -1
+      if (a.kind !== 'general' && b.kind === 'general') return 1
+      return a.createdAt - b.createdAt
+    })
+  }
+})
+
+export const updateSubchannel = mutation({
+  args: {
+    subchannelId: v.id('subchannels'),
+    name: v.optional(v.string()),
+    metadata: v.optional(v.any())
+  },
+  returns: v.null(),
+  handler: async (ctx, args) => {
+    const patch: {
+      updatedAt: number
+      name?: string
+      metadata?: unknown
+    } = { updatedAt: Date.now() }
+    if (args.name !== undefined) patch.name = args.name
+    if (args.metadata !== undefined) patch.metadata = args.metadata
+    await ctx.db.patch(args.subchannelId, patch)
+    return null
+  }
+})
+
+export const archiveSubchannel = mutation({
+  args: {
+    subchannelId: v.id('subchannels'),
+    archived: v.optional(v.boolean())
+  },
+  returns: v.null(),
+  handler: async (ctx, args) => {
+    await ctx.db.patch(args.subchannelId, {
+      archived: args.archived ?? true,
+      updatedAt: Date.now()
+    })
+    return null
+  }
+})
+
+export const deleteSubchannel = mutation({
+  args: { subchannelId: v.id('subchannels') },
+  returns: v.null(),
+  handler: async (ctx, args) => {
+    const messages = await ctx.db
+      .query('messages')
+      .withIndex('by_subchannel_and_time', (q) =>
+        q.eq('subchannelId', args.subchannelId)
+      )
+      .collect()
+
+    for (const message of messages) {
+      await ctx.db.delete(message._id)
+    }
+
+    await ctx.db.delete(args.subchannelId)
+    return null
+  }
+})
+
+/**
+ * MESSAGE CRUD
+ */
+export const sendMessage = mutation({
+  args: {
+    subchannelId: v.id('subchannels'),
+    authorId: v.string(),
+    authorName: v.optional(v.string()),
+    body: v.string(),
+    metadata: v.optional(v.any())
+  },
+  returns: v.id('messages'),
+  handler: async (ctx, args) => {
+    const subchannel = await ctx.db.get(args.subchannelId)
+    if (!subchannel) {
+      throw new Error('Subchannel not found')
+    }
+
+    const now = Date.now()
+    return await ctx.db.insert('messages', {
+      channelId: subchannel.channelId,
+      subchannelId: args.subchannelId,
+      authorId: args.authorId,
+      authorName: args.authorName,
+      body: args.body,
+      metadata: args.metadata,
+      createdAt: now,
+      updatedAt: now
+    })
+  }
+})
+
+export const getMessage = query({
+  args: { messageId: v.id('messages') },
+  handler: async (ctx, args) => await ctx.db.get(args.messageId)
+})
+
+export const listMessages = query({
+  args: {
+    subchannelId: v.id('subchannels'),
+    limit: v.optional(v.number())
+  },
+  handler: async (ctx, args) => {
+    return await ctx.db
+      .query('messages')
+      .withIndex('by_subchannel_and_time', (q) =>
+        q.eq('subchannelId', args.subchannelId)
+      )
+      .order('asc')
+      .take(args.limit ?? 200)
+  }
+})
+
+export const updateMessage = mutation({
+  args: {
+    messageId: v.id('messages'),
+    body: v.string(),
+    metadata: v.optional(v.any())
+  },
+  returns: v.null(),
+  handler: async (ctx, args) => {
+    await ctx.db.patch(args.messageId, {
+      body: args.body,
+      metadata: args.metadata,
+      updatedAt: Date.now()
+    })
+    return null
+  }
+})
+
+export const deleteMessage = mutation({
+  args: { messageId: v.id('messages') },
+  returns: v.null(),
+  handler: async (ctx, args) => {
+    await ctx.db.delete(args.messageId)
+    return null
+  }
+})

package/src/component/schema.ts

@@ -0,0 +1,45 @@
+import { defineSchema, defineTable } from 'convex/server'
+import { v } from 'convex/values'
+
+export default defineSchema({
+  channels: defineTable({
+    // External key from host domain (e.g. patientId in PrimoUp)
+    externalId: v.string(),
+    name: v.string(),
+    archived: v.boolean(),
+    metadata: v.optional(v.any()),
+    createdAt: v.number(),
+    updatedAt: v.number()
+  })
+    .index('by_external_id', ['externalId'])
+    .index('by_archived', ['archived']),
+
+  subchannels: defineTable({
+    channelId: v.id('channels'),
+    name: v.string(),
+    kind: v.union(v.literal('general'), v.literal('custom')),
+    externalReferenceId: v.optional(v.string()),
+    archived: v.boolean(),
+    metadata: v.optional(v.any()),
+    createdAt: v.number(),
+    updatedAt: v.number()
+  })
+    .index('by_channel', ['channelId'])
+    .index('by_channel_and_external_reference', [
+      'channelId',
+      'externalReferenceId'
+    ]),
+
+  messages: defineTable({
+    channelId: v.id('channels'),
+    subchannelId: v.id('subchannels'),
+    authorId: v.string(),
+    authorName: v.optional(v.string()),
+    body: v.string(),
+    metadata: v.optional(v.any()),
+    createdAt: v.number(),
+    updatedAt: v.number()
+  })
+    .index('by_subchannel_and_time', ['subchannelId', 'createdAt'])
+    .index('by_channel_and_time', ['channelId', 'createdAt'])
+})

package/src/index.ts

@@ -0,0 +1 @@
+export { exposeApi } from './client/index.js'