@meeovi/layer-lists 1.0.2 → 1.0.3

package/README.md

@@ -0,0 +1,111 @@
+# @meeovi/layer-lists
+
+This layer provides first-class lists and task management functionality for the Alternate Framework. It's provider-driven: you can plug in different backends (Directus, memory, ATProto, etc.) without changing UI code. The default production-ready fallback is the `@meeovi/directus-client` provider.
+
+Key goals:
+- Provider-agnostic API used by the UI (`useLists()` composable).
+- Advanced task features (due dates, reminders, priority, sharing, search, archive) exposed as optional provider methods.
+- Production-ready defaults: Directus provider, health checks, graceful fallbacks.
+
+Quick start
+
+Install the layer into your project (monorepo/local install):
+
+```bash
+npm install @meeovi/layer-lists
+# also install your chosen provider (Directus example)
+npm install @meeovi/directus-client
+```
+
+Register the layer and configure the provider in your Alternate app (Directus example):
+
+```ts
+import lists from '@meeovi/layer-lists'
+
+const app = createAlternateApp({
+  config: {
+    lists: {
+      provider: 'directus',
+      directus: {
+        baseUrl: 'https://cms.example.com',
+        apiKey: process.env.DIRECTUS_KEY
+      }
+    }
+  },
+  modules: [lists]
+})
+
+await app.start()
+```
+
+Using in a Nuxt (modules) app
+
+1. Install the packages into your Nuxt app project.
+2. Add the layer module to your Nuxt alternate app bootstrap (see above).
+3. In Vue components or composables, use the `useLists()` composable the same way as in the Alternate UI:
+
+```ts
+const { listLists, createList, addItem, updateItem } = useLists()
+
+const lists = await listLists()
+await createList({ title: 'Groceries' })
+await addItem('list-id', { title: 'Buy milk', metadata: { dueDate: '2026-02-01' } })
+```
+
+Advanced features
+
+Providers may implement optional advanced methods:
+- `toggleComplete(listId, itemId, completed)`
+- `setDueDate(listId, itemId, dueDate)`
+- `setReminder(listId, itemId, reminder)`
+- `setPriority(listId, itemId, priority)`
+- `shareList(listId, userId, role)`
+- `searchItems(listId, query)`
+- `archiveList(listId)`
+
+If a provider doesn't implement these methods, the `memory` provider includes sensible defaults and the `directus` provider attempts fallbacks to existing endpoints when possible.
+
+Creating a provider
+
+Implement a `ListsProvider` and register it with `registerListsProvider(name, provider)`.
+
+Example skeleton (register at runtime):
+
+```ts
+import { registerListsProvider } from '@meeovi/layer-lists/app/composables/registry'
+
+const MyProvider = {
+  async getList(id) { /* ... */ },
+  async listLists() { /* ... */ },
+  async createList(data) { /* ... */ },
+  async addItem(listId, item) { /* ... */ },
+  // ... implement optional methods as desired
+}
+
+registerListsProvider('my-provider', MyProvider)
+```
+
+Runtime registration
+
+Other modules can register providers at runtime using `registerListsProviderRuntime(name, provider)`.
+
+Health checks
+
+Use the provided `checkListsProviderHealth()` helper to validate that the configured provider is reachable (it performs a lightweight `listLists()` call). Example:
+
+```ts
+import { checkListsProviderHealth } from '@meeovi/layer-lists/app/composables/utils/health'
+
+const healthy = await checkListsProviderHealth()
+if (!healthy) {
+  // fallback or alert
+}
+```
+
+What's next
+
+- Add server-side sync/notifications (webhooks) for reminders.
+- Add tests and CI for providers and bridges.
+- Provide an Express example wiring server-side endpoints to the Directus client.
+
+License: MIT

package/app/composables/config.ts

@@ -5,7 +5,7 @@ export interface ListsConfig {
 }
 
 let config: ListsConfig = {
-  provider: 'memory'
+  provider: 'directus'
 }
 
 export function setListsConfig(newConfig: Partial<ListsConfig>) {

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

@@ -1,48 +1,144 @@
 import { registerListsProvider } from '../registry'
 import type { ListsProvider } from '../types'
-import { fetcher } from '@meeovi/api'
+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 { data } = await fetcher('lists.GET_LIST', { id })
-    return data.list
+    const json = await directusFetch(`/lists/${id}`)
+    return json.list ?? json
   },
 
   async listLists() {
-    const { data } = await fetcher('lists.LIST_LISTS')
-    return data.lists
+    const json = await directusFetch(`/lists`)
+    return json.lists ?? json
   },
 
   async createList(data) {
-    const { data: result } = await fetcher('lists.CREATE_LIST', { data })
-    return result.list
+    const json = await directusFetch(`/lists`, { method: 'POST', body: JSON.stringify(data) })
+    return json.list ?? json
   },
 
   async updateList(id, data) {
-    const { data: result } = await fetcher('lists.UPDATE_LIST', { id, data })
-    return result.list
+    const json = await directusFetch(`/lists/${id}`, { method: 'PUT', body: JSON.stringify(data) })
+    return json.list ?? json
   },
 
   async deleteList(id) {
-    await fetcher('lists.DELETE_LIST', { id })
+    await directusFetch(`/lists/${id}`, { method: 'DELETE' })
   },
 
   async addItem(listId, item) {
-    const { data } = await fetcher('lists.ADD_ITEM', { listId, item })
-    return data.item
+    const json = await directusFetch(`/lists/${listId}/items`, { method: 'POST', body: JSON.stringify(item) })
+    return json.item ?? json
   },
 
   async updateItem(listId, itemId, data) {
-    const { data: result } = await fetcher('lists.UPDATE_ITEM', { listId, itemId, data })
-    return result.item
+    const json = await directusFetch(`/lists/${listId}/items/${itemId}`, { method: 'PUT', body: JSON.stringify(data) })
+    return json.item ?? json
   },
 
   async deleteItem(listId, itemId) {
-    await fetcher('lists.DELETE_ITEM', { listId, itemId })
+    await directusFetch(`/lists/${listId}/items/${itemId}`, { method: 'DELETE' })
   },
 
   async reorderItems(listId, itemIds) {
-    await fetcher('lists.REORDER_ITEMS', { 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 } }) })
+    }
   }
 }
 

package/app/composables/providers/memory.ts

@@ -82,6 +82,45 @@ const MemoryListsProvider: ListsProvider = {
       ...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 }
   }
 }
 

package/app/composables/registry.ts

@@ -6,6 +6,11 @@ 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`)

package/app/composables/types.ts

@@ -32,4 +32,13 @@ export interface ListsProvider {
   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/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/dist/app/composables/config.d.ts

@@ -0,0 +1,7 @@
+export interface ListsConfig {
+    provider: string;
+    baseUrl?: string;
+    apiKey?: string;
+}
+export declare function setListsConfig(newConfig: Partial<ListsConfig>): void;
+export declare function getListsConfig(): ListsConfig;

package/dist/app/composables/config.js

@@ -0,0 +1,9 @@
+let config = {
+    provider: 'directus'
+};
+export function setListsConfig(newConfig) {
+    config = { ...config, ...newConfig };
+}
+export function getListsConfig() {
+    return config;
+}

package/dist/app/composables/globals/useDirectusForm.d.ts

@@ -0,0 +1,4 @@
+export declare function useDirectusForm(..._args: any[]): {
+    data: any;
+    save: () => Promise<never>;
+};

package/dist/app/composables/globals/useDirectusForm.js

@@ -0,0 +1,10 @@
+// Light stub for isolated typechecks and builds.
+// In the real app this re-exports from the shared layer.
+export function useDirectusForm(..._args) {
+    return {
+        data: null,
+        save: async () => {
+            throw new Error('useDirectusForm stub - not available in isolated build');
+        }
+    };
+}

package/dist/app/composables/module.d.ts

@@ -0,0 +1,7 @@
+import { type AlternateContext } from '@meeovi/core';
+declare const _default: {
+    id: string;
+    adapters: {};
+    setup(ctx: AlternateContext): Promise<void>;
+};
+export default _default;

package/dist/app/composables/module.js

@@ -0,0 +1,60 @@
+import { defineAlternateModule, useAlternateEventBus } from '@meeovi/core';
+import { getListsConfig } from './config';
+import { registerListsProviderRuntime } from './registry';
+export default defineAlternateModule({
+    id: 'lists',
+    adapters: {},
+    async setup(ctx) {
+        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');
+            if (runtimeAdapter) {
+                const provider = {
+                    getList: (id) => runtimeAdapter.getList(id),
+                    listLists: (params) => runtimeAdapter.listLists(params),
+                    createList: (data) => runtimeAdapter.createList(data),
+                    updateList: (id, data) => runtimeAdapter.updateList(id, data),
+                    deleteList: (id) => runtimeAdapter.deleteList(id),
+                    addItem: (listId, item) => runtimeAdapter.addItem(listId, item),
+                    updateItem: (listId, itemId, data) => runtimeAdapter.updateItem(listId, itemId, data),
+                    deleteItem: (listId, itemId) => runtimeAdapter.deleteItem(listId, itemId),
+                    reorderItems: runtimeAdapter.reorderItems ? (listId, itemIds) => runtimeAdapter.reorderItems(listId, itemIds) : undefined
+                };
+                registerListsProviderRuntime('core', provider);
+            }
+        }
+        catch (e) {
+            // noop
+        }
+        // Listen for runtime adapter registrations from ModuleRegistry
+        bus.on('adapter:registered', (payload) => {
+            try {
+                if (payload?.key === 'lists') {
+                    const runtimeAdapter = ctx.getAdapter('lists');
+                    if (runtimeAdapter) {
+                        const provider = {
+                            getList: (id) => runtimeAdapter.getList(id),
+                            listLists: (params) => runtimeAdapter.listLists(params),
+                            createList: (data) => runtimeAdapter.createList(data),
+                            updateList: (id, data) => runtimeAdapter.updateList(id, data),
+                            deleteList: (id) => runtimeAdapter.deleteList(id),
+                            addItem: (listId, item) => runtimeAdapter.addItem(listId, item),
+                            updateItem: (listId, itemId, data) => runtimeAdapter.updateItem(listId, itemId, data),
+                            deleteItem: (listId, itemId) => runtimeAdapter.deleteItem(listId, itemId),
+                            reorderItems: runtimeAdapter.reorderItems ? (listId, itemIds) => runtimeAdapter.reorderItems(listId, itemIds) : undefined
+                        };
+                        registerListsProviderRuntime('core', provider);
+                    }
+                }
+            }
+            catch (e) {
+                /* noop */
+            }
+        });
+    }
+});

package/dist/app/composables/providers/atproto.d.ts

@@ -0,0 +1 @@
+export {};