@meeovi/layer-lists 1.0.2

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/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,49 @@
+import { registerListsProvider } from '../registry'
+import type { ListsProvider } from '../types'
+import { fetcher } from '@meeovi/api'
+
+const DirectusListsProvider: ListsProvider = {
+  async getList(id) {
+    const { data } = await fetcher('lists.GET_LIST', { id })
+    return data.list
+  },
+
+  async listLists() {
+    const { data } = await fetcher('lists.LIST_LISTS')
+    return data.lists
+  },
+
+  async createList(data) {
+    const { data: result } = await fetcher('lists.CREATE_LIST', { data })
+    return result.list
+  },
+
+  async updateList(id, data) {
+    const { data: result } = await fetcher('lists.UPDATE_LIST', { id, data })
+    return result.list
+  },
+
+  async deleteList(id) {
+    await fetcher('lists.DELETE_LIST', { id })
+  },
+
+  async addItem(listId, item) {
+    const { data } = await fetcher('lists.ADD_ITEM', { listId, item })
+    return data.item
+  },
+
+  async updateItem(listId, itemId, data) {
+    const { data: result } = await fetcher('lists.UPDATE_ITEM', { listId, itemId, data })
+    return result.item
+  },
+
+  async deleteItem(listId, itemId) {
+    await fetcher('lists.DELETE_ITEM', { listId, itemId })
+  },
+
+  async reorderItems(listId, itemIds) {
+    await fetcher('lists.REORDER_ITEMS', { listId, itemIds })
+  }
+}
+
+registerListsProvider('directus', DirectusListsProvider)

package/app/composables/providers/memory.ts

@@ -0,0 +1,88 @@
+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
+    }))
+  }
+}
+
+registerListsProvider('memory', MemoryListsProvider)

package/app/composables/registry.ts

@@ -0,0 +1,13 @@
+import type { ListsProvider } from './types'
+
+const providers: Record<string, ListsProvider> = {}
+
+export function registerListsProvider(name: string, provider: ListsProvider) {
+  providers[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,35 @@
+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>
+}

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

package/app/pages/lists/bookmark/[id].vue

@@ -0,0 +1,76 @@
+<template>
+    <v-row class="contentPage">
+        <v-col cols="12">
+            <v-card class="mx-auto" max-width="800px" elevation="0">
+                <NuxtImg loading="lazy" class="align-end text-white" height="200" :src="`${$directus.url}/assets/${website?.image?.filename_disk}`" :alt="website?.name" cover />
+                <v-card-title>{{ website?.name }}</v-card-title>
+
+                <v-card-subtitle class="pt-4">
+                    Created: {{ new Date(website?.created_at).toLocaleDateString() }}
+                </v-card-subtitle>
+
+                <v-card-text>
+                    <div>Type: {{ website?.type }}</div>
+
+                    <div>{{ website?.note }}</div>
+                </v-card-text>
+
+                <v-card-actions>
+                    <updatebookmark />
+
+                    <v-spacer></v-spacer>
+                    <v-btn color="orange" text="Visit" :href="website?.url"></v-btn>
+                </v-card-actions>
+            </v-card>
+        </v-col>
+
+        <v-divider></v-divider>
+        <v-col cols="12">
+            <comments />
+        </v-col>
+    </v-row>
+</template>
+
+<script setup>
+    import {
+        ref,
+        computed
+    } from 'vue'
+    import updatebookmark from '#lists/app/components/lists/update-bookmark.vue'
+    import createListBtn from '#lists/app/components/partials/createListBtn.vue'
+    import comments from '#social/app/components/comments.vue'
+
+    const route = useRoute();
+
+    const {
+        $directus,
+        $readItem
+    } = useNuxtApp()
+
+    const {
+        data: website
+    } = await useAsyncData('website', () => {
+        return $directus.request($readItem('websites', route.params.id, {
+            fields: ['*', {
+                '*': ['*']
+            }]
+        }))
+    })
+
+
+    // Add this debug log
+    watchEffect(() => {
+        if (website.value) {
+            console.log('Fetched website data:', website.value)
+        }
+    })
+
+
+    useHead({
+        title: computed(() => website?.value?.name || 'Bookmark Page')
+    })
+
+    definePageMeta({
+        middleware: ['authenticated'],
+    })
+</script>