@meeovi/layer-lists 1.0.6 → 1.0.10

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/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
+}

package/app/composables/types.ts

@@ -0,0 +1,44 @@
+export interface ListItem {
+  id: string
+  title: string
+  description?: string
+  completed?: boolean
+  position?: number
+  parentId?: string
+  metadata?: Record<string, any>
+  createdAt?: string
+  updatedAt?: string
+}
+
+export interface List {
+  id: string
+  title: string
+  type: 'checklist' | 'kanban' | 'list' | string
+  items: ListItem[]
+  metadata?: Record<string, any>
+  createdAt?: string
+  updatedAt?: string
+}
+
+export interface ListsProvider {
+  getList(id: string): Promise<List>
+  listLists(params?: Record<string, any>): Promise<List[]>
+  createList(data: Partial<List>): Promise<List>
+  updateList(id: string, data: Partial<List>): Promise<List>
+  deleteList(id: string): Promise<void>
+
+  addItem(listId: string, item: Partial<ListItem>): Promise<ListItem>
+  updateItem(listId: string, itemId: string, data: Partial<ListItem>): Promise<ListItem>
+  deleteItem(listId: string, itemId: string): Promise<void>
+
+  reorderItems?(listId: string, itemIds: string[]): Promise<void>
+
+  // Optional advanced features commonly found in task apps
+  toggleComplete?(listId: string, itemId: string, completed: boolean): Promise<ListItem>
+  setDueDate?(listId: string, itemId: string, dueDate: string | null): Promise<ListItem>
+  setReminder?(listId: string, itemId: string, reminder: string | null): Promise<ListItem>
+  setPriority?(listId: string, itemId: string, priority: number | null): Promise<ListItem>
+  shareList?(listId: string, userId: string, role?: string): Promise<void>
+  searchItems?(listId: string, query: string): Promise<ListItem[]>
+  archiveList?(listId: string): Promise<void>
+}

package/app/composables/useLists.ts

@@ -0,0 +1,20 @@
+import { getListsConfig } from './config'
+import { getListsProvider } from './registry'
+
+export function useLists() {
+  const { provider } = getListsConfig()
+  const lists = getListsProvider(provider)
+
+  return {
+    getList: lists.getList,
+    listLists: lists.listLists,
+    createList: lists.createList,
+    updateList: lists.updateList,
+    deleteList: lists.deleteList,
+
+    addItem: lists.addItem,
+    updateItem: lists.updateItem,
+    deleteItem: lists.deleteItem,
+    reorderItems: lists.reorderItems
+  }
+}

package/app/composables/utils/health.ts

@@ -0,0 +1,16 @@
+import { getListsProvider } from '../registry'
+import { getListsConfig } from '../config'
+
+export async function checkListsProviderHealth(providerName?: string) {
+  try {
+    const cfg = getListsConfig()
+    const name = providerName || cfg.provider || 'directus'
+    const provider = getListsProvider(name)
+    const lists = await provider.listLists()
+    return { ok: true, count: Array.isArray(lists) ? lists.length : null }
+  } catch (e: any) {
+    return { ok: false, error: e?.message || String(e) }
+  }
+}
+
+export default checkListsProviderHealth

package/app/composables/utils/transforms.ts

@@ -0,0 +1,42 @@
+import type { List, ListItem } from '../types'
+
+/**
+ * Normalize a raw provider list into Meeovi's List shape.
+ */
+export function transformList(raw: any): List {
+  return {
+    id: raw.id,
+    title: raw.title ?? raw.name ?? 'Untitled',
+    type: raw.type ?? 'list',
+    items: Array.isArray(raw.items)
+      ? raw.items.map(transformItem)
+      : [],
+    metadata: raw.metadata ?? {},
+    createdAt: raw.createdAt ?? raw.created_at ?? null,
+    updatedAt: raw.updatedAt ?? raw.updated_at ?? null
+  }
+}
+
+/**
+ * Normalize a raw provider item into Meeovi's ListItem shape.
+ */
+export function transformItem(raw: any): ListItem {
+  return {
+    id: raw.id,
+    title: raw.title ?? raw.name ?? '',
+    description: raw.description ?? raw.body ?? '',
+    completed: raw.completed ?? raw.done ?? false,
+    position: raw.position ?? raw.order ?? 0,
+    parentId: raw.parentId ?? raw.parent_id ?? null,
+    metadata: raw.metadata ?? {},
+    createdAt: raw.createdAt ?? raw.created_at ?? null,
+    updatedAt: raw.updatedAt ?? raw.updated_at ?? null
+  }
+}
+
+/**
+ * Normalize arrays safely.
+ */
+export function transformListArray(raw: any[]): List[] {
+  return raw.map(transformList)
+}

package/app/composables/utils/validation.ts

@@ -0,0 +1,21 @@
+import type { List, ListItem } from '../types'
+
+export function validateListInput(data: Partial<List>) {
+  if (!data.title || typeof data.title !== 'string') {
+    throw new Error('List title is required and must be a string')
+  }
+
+  if (data.type && typeof data.type !== 'string') {
+    throw new Error('List type must be a string')
+  }
+}
+
+export function validateItemInput(data: Partial<ListItem>) {
+  if (!data.title || typeof data.title !== 'string') {
+    throw new Error('Item title is required and must be a string')
+  }
+
+  if (data.completed !== undefined && typeof data.completed !== 'boolean') {
+    throw new Error('Item completed must be a boolean')
+  }
+}