@meeovi/layer-lists 1.0.6 → 1.0.8

package/app/composables/lists/useSaved.js

@@ -0,0 +1,29 @@
+export const useSaved = () => {
+    const { $directus } = useNuxtApp();
+    const user = useSupabaseUser();
+  
+    const isSaved = async (productId) => {
+      if (!user.value) return false;
+  
+      const lists = await $directus.items('lists').readItems({
+        filter: { user: { _eq: user.value.id } },
+        fields: ['id']
+      });
+  
+      const listIds = lists.map((l) => l.id);
+  
+      if (listIds.length === 0) return false;
+  
+      const saved = await $directus.items('list_items').readItems({
+        filter: {
+          list: { _in: listIds },
+          product: { _eq: productId }
+        }
+      });
+  
+      return saved.length > 0;
+    };
+  
+    return { isSaved };
+  };
+  

package/app/composables/lists/useTasks.js

@@ -0,0 +1,86 @@
+export const useTasks = () => {
+  const { createList, addToList, getUserLists, updateListItem } = useLists()
+
+  const createTaskList = async (name, description = '') => {
+    return await createList({
+      name,
+      description,
+      type: 'tasks',
+      visibility: 'private'
+    })
+  }
+
+  const addTask = async (listId, taskData) => {
+    const { title, description, priority, due_date, labels } = taskData
+    
+    return await addToList(listId, {
+      type: 'task',
+      title,
+      description,
+      priority: priority || 'medium',
+      due_date,
+      labels: labels || [],
+      completed: false,
+      date_created: new Date().toISOString(),
+      subtasks: []
+    })
+  }
+
+  const completeTask = async (itemId) => {
+    return await updateListItem(itemId, {
+      'content.completed': true,
+      'content.date_completed': new Date().toISOString()
+    })
+  }
+
+  const uncompleteTask = async (itemId) => {
+    return await updateListItem(itemId, {
+      'content.completed': false,
+      'content.date_completed': null
+    })
+  }
+
+  const updateTaskPriority = async (itemId, priority) => {
+    return await updateListItem(itemId, {
+      'content.priority': priority
+    })
+  }
+
+  const updateTaskDueDate = async (itemId, dueDate) => {
+    return await updateListItem(itemId, {
+      'content.due_date': dueDate
+    })
+  }
+
+  const addSubtask = async (itemId, subtaskTitle) => {
+    const { getListById } = useLists()
+    const item = await getListById(itemId)
+    const subtasks = item.content.subtasks || []
+    
+    subtasks.push({
+      id: Date.now(),
+      title: subtaskTitle,
+      completed: false,
+      date_created: new Date().toISOString()
+    })
+
+    return await updateListItem(itemId, {
+      'content.subtasks': subtasks
+    })
+  }
+
+  const getUserTaskLists = async () => {
+    return await getUserLists('tasks')
+  }
+
+  return {
+    createTaskList,
+    addTask,
+    completeTask,
+    uncompleteTask,
+    updateTaskPriority,
+    updateTaskDueDate,
+    addSubtask,
+    getUserTaskLists
+  }
+}

package/app/composables/lists/useWishlist.js

@@ -0,0 +1,51 @@
+export const useWishlist = () => {
+  const { createList, addToList, getUserLists, removeFromList } = useLists()
+
+  const createWishlist = async (name = 'My Wishlist', description = '') => {
+    return await createList({
+      name,
+      description,
+      type: 'wishlist',
+      visibility: 'private'
+    })
+  }
+
+  const addToWishlist = async (wishlistId, itemData) => {
+    const { title, url, price, image, description, category } = itemData
+    
+    return await addToList(wishlistId, {
+      type: 'product',
+      title,
+      url,
+      price,
+      image,
+      description,
+      category,
+      date_added: new Date().toISOString(),
+      priority: itemData.priority || 'medium'
+    })
+  }
+
+  const getUserWishlists = async () => {
+    return await getUserLists('wishlist')
+  }
+
+  const removeFromWishlist = async (itemId) => {
+    return await removeFromList(itemId)
+  }
+
+  const updateWishlistItemPriority = async (itemId, priority) => {
+    const { updateListItem } = useLists()
+    return await updateListItem(itemId, { 
+      'content.priority': priority 
+    })
+  }
+
+  return {
+    createWishlist,
+    addToWishlist,
+    getUserWishlists,
+    removeFromWishlist,
+    updateWishlistItemPriority
+  }
+}

package/app/composables/module.ts

@@ -0,0 +1,75 @@
+import {
+  defineAlternateModule,
+  useAlternateEventBus,
+  useAlternateContext,
+  type AlternateContext,
+  type ListsAdapter
+} from '@meeovi/core'
+
+import { getListsConfig } from './config'
+import { registerListsProviderRuntime } from './registry'
+
+export default defineAlternateModule({
+  id: 'lists',
+  adapters: {},
+
+  async setup(ctx: AlternateContext) {
+    const bus = useAlternateEventBus()
+    const config = getListsConfig()
+
+    // If a core adapter was registered under the `lists` key, register it
+    // into the local provider registry so UI code can consume it via `useLists()`.
+    // If a core adapter was registered under the `lists` key, adapt it
+    // into the `ListsProvider` shape and register it into the local registry.
+    try {
+      const runtimeAdapter = ctx.getAdapter('lists' as any) as ListsAdapter | undefined
+      if (runtimeAdapter) {
+        const provider = {
+          getList: (id: string) => runtimeAdapter.getList(id),
+          listLists: (params?: Record<string, unknown>) => runtimeAdapter.listLists(params),
+          createList: (data: Partial<Record<string, unknown>>) => runtimeAdapter.createList(data),
+          updateList: (id: string, data: Partial<Record<string, unknown>>) => runtimeAdapter.updateList(id, data),
+          deleteList: (id: string) => runtimeAdapter.deleteList(id),
+
+          addItem: (listId: string, item: Partial<Record<string, unknown>>) => runtimeAdapter.addItem(listId, item),
+          updateItem: (listId: string, itemId: string, data: Partial<Record<string, unknown>>) => runtimeAdapter.updateItem(listId, itemId, data),
+          deleteItem: (listId: string, itemId: string) => runtimeAdapter.deleteItem(listId, itemId),
+
+          reorderItems: runtimeAdapter.reorderItems ? (listId: string, itemIds: string[]) => runtimeAdapter.reorderItems!(listId, itemIds) : undefined
+        }
+
+        registerListsProviderRuntime('core', provider)
+      }
+    } catch (e) {
+      // noop
+    }
+
+    // Listen for runtime adapter registrations from ModuleRegistry
+    bus.on('adapter:registered' as any, (payload: any) => {
+      try {
+        if (payload?.key === 'lists') {
+          const runtimeAdapter = ctx.getAdapter('lists' as any) as ListsAdapter | undefined
+          if (runtimeAdapter) {
+            const provider = {
+              getList: (id: string) => runtimeAdapter.getList(id),
+              listLists: (params?: Record<string, unknown>) => runtimeAdapter.listLists(params),
+              createList: (data: Partial<Record<string, unknown>>) => runtimeAdapter.createList(data),
+              updateList: (id: string, data: Partial<Record<string, unknown>>) => runtimeAdapter.updateList(id, data),
+              deleteList: (id: string) => runtimeAdapter.deleteList(id),
+
+              addItem: (listId: string, item: Partial<Record<string, unknown>>) => runtimeAdapter.addItem(listId, item),
+              updateItem: (listId: string, itemId: string, data: Partial<Record<string, unknown>>) => runtimeAdapter.updateItem(listId, itemId, data),
+              deleteItem: (listId: string, itemId: string) => runtimeAdapter.deleteItem(listId, itemId),
+
+              reorderItems: runtimeAdapter.reorderItems ? (listId: string, itemIds: string[]) => runtimeAdapter.reorderItems!(listId, itemIds) : undefined
+            }
+
+            registerListsProviderRuntime('core', provider)
+          }
+        }
+      } catch (e) {
+        /* noop */
+      }
+    })
+  }
+})

package/app/composables/providers/atproto.ts

@@ -0,0 +1,156 @@
+import { registerListsProvider } from '../registry'
+import type { ListsProvider, List, ListItem } from '../types'
+import { wrapSocialRequest } from '@meeovi/social'
+import { transformList, transformItem } from '../utils/transforms'
+import { validateListInput, validateItemInput } from '../utils/validation'
+import { getListsConfig } from '../config'
+
+async function atprotoFetch(path: string, options: RequestInit = {}) {
+  const { baseUrl, apiKey } = getListsConfig()
+
+  const res = await fetch(`${baseUrl}${path}`, {
+    ...options,
+    headers: {
+      'Content-Type': 'application/json',
+      ...(apiKey ? { Authorization: `Bearer ${apiKey}` } : {}),
+      ...(options.headers || {})
+    }
+  })
+
+  if (!res.ok) {
+    const error: any = new Error(`ATProto error: ${res.status}`)
+    error.status = res.status
+    error.response = res
+    throw error
+  }
+
+  return res.json()
+}
+
+const AtprotoListsProvider: ListsProvider = {
+  async getList(id) {
+    return wrapSocialRequest('atproto', async () => {
+      const data = await atprotoFetch(`/xrpc/app.bsky.graph.getList?list=${id}`)
+      return transformList(data.list)
+    }, {
+      cacheKey: `atproto:list:${id}`,
+      ttlMs: 1000 * 30,
+      retry: true,
+      swr: true
+    })
+  },
+
+  async listLists() {
+    return wrapSocialRequest('atproto', async () => {
+      const data = await atprotoFetch(`/xrpc/app.bsky.graph.getLists`)
+      return data.lists.map(transformList)
+    }, {
+      cacheKey: `atproto:lists`,
+      ttlMs: 1000 * 30,
+      retry: true,
+      swr: true
+    })
+  },
+
+  async createList(data) {
+    validateListInput(data)
+
+    return wrapSocialRequest('atproto', async () => {
+      const result = await atprotoFetch(`/xrpc/app.bsky.graph.createList`, {
+        method: 'POST',
+        body: JSON.stringify({
+          name: data.title,
+          purpose: data.type ?? 'list',
+          description: data.metadata?.description ?? ''
+        })
+      })
+
+      return transformList(result)
+    })
+  },
+
+  async updateList(id, data) {
+    validateListInput(data)
+
+    return wrapSocialRequest('atproto', async () => {
+      const result = await atprotoFetch(`/xrpc/app.bsky.graph.updateList`, {
+        method: 'POST',
+        body: JSON.stringify({
+          list: id,
+          name: data.title,
+          description: data.metadata?.description
+        })
+      })
+
+      return transformList(result)
+    })
+  },
+
+  async deleteList(id) {
+    return wrapSocialRequest('atproto', async () => {
+      await atprotoFetch(`/xrpc/app.bsky.graph.deleteList`, {
+        method: 'POST',
+        body: JSON.stringify({ list: id })
+      })
+    })
+  },
+
+  async addItem(listId, item) {
+    validateItemInput(item)
+
+    return wrapSocialRequest('atproto', async () => {
+      const result = await atprotoFetch(`/xrpc/app.bsky.graph.addListItem`, {
+        method: 'POST',
+        body: JSON.stringify({
+          list: listId,
+          subject: item.title // ATProto uses "subject" for list entries
+        })
+      })
+
+      return transformItem(result)
+    })
+  },
+
+  async updateItem(listId, itemId, data) {
+    validateItemInput(data)
+
+    return wrapSocialRequest('atproto', async () => {
+      const result = await atprotoFetch(`/xrpc/app.bsky.graph.updateListItem`, {
+        method: 'POST',
+        body: JSON.stringify({
+          list: listId,
+          item: itemId,
+          ...data
+        })
+      })
+
+      return transformItem(result)
+    })
+  },
+
+  async deleteItem(listId, itemId) {
+    return wrapSocialRequest('atproto', async () => {
+      await atprotoFetch(`/xrpc/app.bsky.graph.deleteListItem`, {
+        method: 'POST',
+        body: JSON.stringify({
+          list: listId,
+          item: itemId
+        })
+      })
+    })
+  },
+
+  async reorderItems(listId, itemIds) {
+    return wrapSocialRequest('atproto', async () => {
+      await atprotoFetch(`/xrpc/app.bsky.graph.reorderListItems`, {
+        method: 'POST',
+        body: JSON.stringify({
+          list: listId,
+          items: itemIds
+        })
+      })
+    })
+  }
+}
+
+registerListsProvider('atproto', AtprotoListsProvider)

package/app/composables/providers/directus.ts

@@ -0,0 +1,145 @@
+import { registerListsProvider } from '../registry'
+import type { ListsProvider } from '../types'
+import { getListsConfig } from '../config'
+
+async function directusFetch(path: string, options: RequestInit = {}) {
+  const cfg = getListsConfig()
+  const base = cfg.baseUrl?.replace(/\/$/, '') || ''
+
+  const res = await fetch(`${base}${path}`, {
+    ...options,
+    headers: {
+      'Content-Type': 'application/json',
+      ...(cfg.apiKey ? { Authorization: `Bearer ${cfg.apiKey}` } : {}),
+      ...(options.headers || {})
+    }
+  })
+
+  if (!res.ok) {
+    const err: any = new Error(`Directus error: ${res.status}`)
+    err.status = res.status
+    err.response = res
+    throw err
+  }
+
+  return res.json()
+}
+
+const DirectusListsProvider: ListsProvider = {
+  async getList(id) {
+    const json = await directusFetch(`/lists/${id}`)
+    return json.list ?? json
+  },
+
+  async listLists() {
+    const json = await directusFetch(`/lists`)
+    return json.lists ?? json
+  },
+
+  async createList(data) {
+    const json = await directusFetch(`/lists`, { method: 'POST', body: JSON.stringify(data) })
+    return json.list ?? json
+  },
+
+  async updateList(id, data) {
+    const json = await directusFetch(`/lists/${id}`, { method: 'PUT', body: JSON.stringify(data) })
+    return json.list ?? json
+  },
+
+  async deleteList(id) {
+    await directusFetch(`/lists/${id}`, { method: 'DELETE' })
+  },
+
+  async addItem(listId, item) {
+    const json = await directusFetch(`/lists/${listId}/items`, { method: 'POST', body: JSON.stringify(item) })
+    return json.item ?? json
+  },
+
+  async updateItem(listId, itemId, data) {
+    const json = await directusFetch(`/lists/${listId}/items/${itemId}`, { method: 'PUT', body: JSON.stringify(data) })
+    return json.item ?? json
+  },
+
+  async deleteItem(listId, itemId) {
+    await directusFetch(`/lists/${listId}/items/${itemId}`, { method: 'DELETE' })
+  },
+
+  async reorderItems(listId, itemIds) {
+    await directusFetch(`/lists/${listId}/reorder`, { method: 'POST', body: JSON.stringify({ items: itemIds }) })
+  },
+
+  async toggleComplete(listId, itemId, completed = true) {
+    try {
+      const json = await directusFetch(`/lists/${listId}/items/${itemId}/toggle`, { method: 'POST', body: JSON.stringify({ completed }) })
+      return json.item ?? json
+    } catch (e) {
+      const json = await directusFetch(`/lists/${listId}/items/${itemId}`, { method: 'PUT', body: JSON.stringify({ completed }) })
+      return json.item ?? json
+    }
+  },
+
+  async setDueDate(listId, itemId, dueDate) {
+    try {
+      const json = await directusFetch(`/lists/${listId}/items/${itemId}/due`, { method: 'POST', body: JSON.stringify({ dueDate }) })
+      return json.item ?? json
+    } catch (e) {
+      const json = await directusFetch(`/lists/${listId}/items/${itemId}`, { method: 'PUT', body: JSON.stringify({ metadata: { dueDate } }) })
+      return json.item ?? json
+    }
+  },
+
+  async setReminder(listId, itemId, reminder) {
+    try {
+      const json = await directusFetch(`/lists/${listId}/items/${itemId}/reminder`, { method: 'POST', body: JSON.stringify({ reminder }) })
+      return json.item ?? json
+    } catch (e) {
+      const json = await directusFetch(`/lists/${listId}/items/${itemId}`, { method: 'PUT', body: JSON.stringify({ metadata: { reminder } }) })
+      return json.item ?? json
+    }
+  },
+
+  async setPriority(listId, itemId, priority) {
+    try {
+      const json = await directusFetch(`/lists/${listId}/items/${itemId}/priority`, { method: 'POST', body: JSON.stringify({ priority }) })
+      return json.item ?? json
+    } catch (e) {
+      const json = await directusFetch(`/lists/${listId}/items/${itemId}`, { method: 'PUT', body: JSON.stringify({ metadata: { priority } }) })
+      return json.item ?? json
+    }
+  },
+
+  async shareList(listId, userId, role = 'editor') {
+    try {
+      await directusFetch(`/lists/${listId}/share`, { method: 'POST', body: JSON.stringify({ userId, role }) })
+    } catch (e) {
+      const json = await directusFetch(`/lists/${listId}`)
+      const list = json.list ?? json
+      const collaborators = (list.metadata?.collaborators || []).concat({ userId, role })
+      await directusFetch(`/lists/${listId}`, { method: 'PUT', body: JSON.stringify({ metadata: { ...(list.metadata || {}), collaborators } }) })
+    }
+  },
+
+  async searchItems(listId, query) {
+    try {
+      const json = await directusFetch(`/lists/${listId}/search?q=${encodeURIComponent(String(query))}`)
+      return json.items ?? json
+    } catch (e) {
+      const json = await directusFetch(`/lists/${listId}`)
+      const list = json.list ?? json
+      const q = String(query).toLowerCase()
+      return list.items.filter((i: any) => (i.title || '').toLowerCase().includes(q) || (i.description || '').toLowerCase().includes(q))
+    }
+  },
+
+  async archiveList(listId) {
+    try {
+      await directusFetch(`/lists/${listId}/archive`, { method: 'POST' })
+    } catch (e) {
+      const json = await directusFetch(`/lists/${listId}`)
+      const list = json.list ?? json
+      await directusFetch(`/lists/${listId}`, { method: 'PUT', body: JSON.stringify({ metadata: { ...(list.metadata || {}), archived: true } }) })
+    }
+  }
+}
+
+registerListsProvider('directus', DirectusListsProvider)

package/app/composables/providers/memory.ts

@@ -0,0 +1,127 @@
+import { registerListsProvider } from '../registry'
+import type { List, ListItem, ListsProvider } from '../types'
+import { nanoid } from 'nanoid'
+
+const lists = new Map<string, List>()
+
+const MemoryListsProvider: ListsProvider = {
+  async getList(id) {
+    const list = lists.get(id)
+    if (!list) throw new Error(`List ${id} not found`)
+    return list
+  },
+
+  async listLists() {
+    return Array.from(lists.values())
+  },
+
+  async createList(data) {
+    const id = nanoid()
+    const list: List = {
+      id,
+      title: data.title || 'Untitled List',
+      type: data.type || 'list',
+      items: [],
+      metadata: data.metadata || {},
+      createdAt: new Date().toISOString(),
+      updatedAt: new Date().toISOString()
+    }
+    lists.set(id, list)
+    return list
+  },
+
+  async updateList(id, data) {
+    const list = await this.getList(id)
+    const updated = {
+      ...list,
+      ...data,
+      updatedAt: new Date().toISOString()
+    }
+    lists.set(id, updated)
+    return updated
+  },
+
+  async deleteList(id) {
+    lists.delete(id)
+  },
+
+  async addItem(listId, item) {
+    const list = await this.getList(listId)
+    const newItem: ListItem = {
+      id: nanoid(),
+      title: item.title || '',
+      description: item.description,
+      completed: item.completed || false,
+      position: list.items.length,
+      parentId: item.parentId,
+      metadata: item.metadata || {},
+      createdAt: new Date().toISOString(),
+      updatedAt: new Date().toISOString()
+    }
+    list.items.push(newItem)
+    return newItem
+  },
+
+  async updateItem(listId, itemId, data) {
+    const list = await this.getList(listId)
+    const item = list.items.find(i => i.id === itemId)
+    if (!item) throw new Error(`Item ${itemId} not found`)
+    Object.assign(item, data, { updatedAt: new Date().toISOString() })
+    return item
+  },
+
+  async deleteItem(listId, itemId) {
+    const list = await this.getList(listId)
+    list.items = list.items.filter(i => i.id !== itemId)
+  },
+
+  async reorderItems(listId, itemIds) {
+    const list = await this.getList(listId)
+    const newOrder = itemIds.map(id => list.items.find(i => i.id === id)!)
+    list.items = newOrder.map((item, index) => ({
+      ...item,
+      position: index
+    }))
+  },
+
+  async toggleComplete(listId, itemId, completed = true) {
+    const item = await this.updateItem(listId, itemId, { completed })
+    return item
+  },
+
+  async setDueDate(listId, itemId, dueDate) {
+    const item = await this.updateItem(listId, itemId, { metadata: { ...( (await this.getList(listId)).items.find(i => i.id === itemId)?.metadata || {} ), dueDate } })
+    return item
+  },
+
+  async setReminder(listId, itemId, reminder) {
+    const item = await this.updateItem(listId, itemId, { metadata: { ...( (await this.getList(listId)).items.find(i => i.id === itemId)?.metadata || {} ), reminder } })
+    return item
+  },
+
+  async setPriority(listId, itemId, priority) {
+    const item = await this.updateItem(listId, itemId, { metadata: { ...( (await this.getList(listId)).items.find(i => i.id === itemId)?.metadata || {} ), priority } })
+    return item
+  },
+
+  async shareList(listId, userId, role = 'editor') {
+    // memory store: attach collaborators in list.metadata.collaborators
+    const list = await this.getList(listId)
+    const collaborators = (list.metadata?.collaborators as any[]) || []
+    collaborators.push({ userId, role })
+    list.metadata = { ...(list.metadata || {}), collaborators }
+  },
+
+  async searchItems(listId, query) {
+    const list = await this.getList(listId)
+    const q = String(query).toLowerCase()
+    return list.items.filter(i => (i.title || '').toLowerCase().includes(q) || (i.description || '').toLowerCase().includes(q))
+  },
+
+  async archiveList(listId) {
+    const list = await this.getList(listId)
+    list.metadata = { ...(list.metadata || {}), archived: true }
+  }
+}
+
+registerListsProvider('memory', MemoryListsProvider)

package/app/composables/registry.ts

@@ -0,0 +1,18 @@
+import type { ListsProvider } from './types'
+
+const providers: Record<string, ListsProvider> = {}
+
+export function registerListsProvider(name: string, provider: ListsProvider) {
+  providers[name] = provider
+}
+
+// Allow runtime registration from other modules (e.g. via core ModuleRegistry adapters)
+export function registerListsProviderRuntime(name: string, provider: ListsProvider) {
+  registerListsProvider(name, provider)
+}
+
+export function getListsProvider(name: string): ListsProvider {
+  const provider = providers[name]
+  if (!provider) throw new Error(`Lists provider "${name}" not found`)
+  return provider
+}