@meeovi/layer-social 1.0.3

package/app/components/related/space.vue

@@ -0,0 +1,47 @@
+<template>
+    <div>
+        <v-card class="mx-auto" max-width="400" height="550">
+            <img v-if="space?.image?.filename_disk" class="align-end text-white" height="200"
+                :src="`${$directus.url}assets/${space?.image?.filename_disk}`" :alt="space?.name" />
+
+            <img class="align-end text-white" height="200" v-else src="assets/images/background8.jpg" :alt="space?.name" />
+
+            <v-card-title>{{ space?.name }}</v-card-title>
+
+            <v-card-subtitle class="pt-4">
+                Created: {{ new Date(space?.date_created).toLocaleDateString() }}
+            </v-card-subtitle>
+
+            <v-card-text>
+                <div v-dompurify-html="space?.description"></div>
+            </v-card-text>
+
+            <v-card-actions>
+                <share style="position: relative; top: 0px;" />
+
+                <v-btn color="orange" text="Explore" :href="`/space/${space?.slug}`"></v-btn>
+            </v-card-actions>
+        </v-card>
+    </div>
+</template>
+
+<script setup>
+    import {
+        ref
+    } from 'vue'
+    import share from '../blocks/share.vue'
+    const {
+        $directus
+    } = useNuxtApp()
+
+    const model = ref(null)
+    const props = defineProps({
+        space: {
+            type: Object,
+            required: true,
+        },
+    });
+    const {
+        space
+    } = props;
+</script>

package/app/components/related/tag.vue

@@ -0,0 +1,21 @@
+<template>
+    <div>
+        <div class="text-center">
+            <v-chip class="ma-2" label :to="`/hashtag/${tag?.slug}`">
+                {{ tag?.name }}
+            </v-chip>
+        </div>
+    </div>
+</template>
+
+<script setup>
+    const props = defineProps({
+        tag: {
+            type: Object,
+            required: true,
+        },
+    });
+    const {
+        tag
+    } = props;
+</script>

package/app/composables/cache.ts

@@ -0,0 +1,44 @@
+export interface CacheEntry<T> {
+  value: T
+  expiresAt: number
+}
+
+export interface SocialCache {
+  store: any
+  get<T>(key: string): T | null
+  set<T>(key: string, value: T, ttlMs: number): void
+  delete(key: string): void
+}
+
+let cache: SocialCache = {
+  store: new Map<string, CacheEntry<any>>(),
+
+  get<T>(key: string): T | null {
+    const entry = this.store.get(key)
+    if (!entry) return null
+    if (Date.now() > entry.expiresAt) {
+      this.store.delete(key)
+      return null
+    }
+    return entry.value
+  },
+
+  set<T>(key: string, value: T, ttlMs: number) {
+    this.store.set(key, {
+      value,
+      expiresAt: Date.now() + ttlMs
+    })
+  },
+
+  delete(key: string) {
+    this.store.delete(key)
+  }
+}
+
+export function setSocialCache(customCache: SocialCache) {
+  cache = customCache
+}
+
+export function getSocialCache() {
+  return cache
+}

package/app/composables/charts/createChart.js

@@ -0,0 +1,33 @@
+// composables/createPost.js
+import { createItem } from '@directus/sdk';
+
+export default async function createPost(chartData) {
+    const route = useRoute();
+
+    const id = route.params.id;
+    const { $directus } = useNuxtApp();
+  
+    try {
+      const chart = await $directus.request(createItem('musicchart', [
+        {
+          name: chartData.name,
+          description: chartData.description,
+          status: chartData.status,
+          type: chartData.type,
+          image: chartData.image,
+          media: chartData.media,
+          video: chartData.video,
+          document: chartData.document,
+          color: chartData.color,
+          coverFile: null,
+          avatarFile: null,
+          creator: chartData.creator,
+        }
+      ]));
+      return chart;
+    } catch (error) {
+      console.error('Error creating chart:', error);
+      throw error;
+    }
+  }
+  

package/app/composables/charts/deleteChart.js

@@ -0,0 +1,15 @@
+// composables/deleteChart.js
+import { deleteItem } from '@directus/sdk';
+
+export default async function deleteChart(chartId) {
+    const { $directus } = useNuxtApp();
+  
+    try {
+      $directus.request(deleteItem('musicchart', chartId));
+      console.log('Chart deleted successfully');
+    } catch (error) {
+      console.error('Error deleting chart:', error);
+      throw error;
+    }
+  }
+  

package/app/composables/charts/updateChart.js

@@ -0,0 +1,15 @@
+// composables/updateChart.js
+import { updateItem } from '@directus/sdk';
+
+export default async function updateChart(chartId, chartData) {
+    const { $directus } = useNuxtApp();
+  
+    try {
+      const chart = await $directus.request(updateItem('musicchart', chartId));
+      return chart;
+    } catch (error) {
+      console.error('Error updating chart:', error);
+      throw error;
+    }
+  }
+  

package/app/composables/config.ts

@@ -0,0 +1,20 @@
+export interface SocialConfig {
+  provider: string
+  baseUrl?: string
+  apiKey?: string
+  [key: string]: any
+}
+
+let config: SocialConfig = {
+  provider: 'atproto',
+  baseUrl: '',
+  apiKey: ''
+}
+
+export function setSocialConfig(newConfig: Partial<SocialConfig>) {
+  config = { ...config, ...newConfig }
+}
+
+export function getSocialConfig(): SocialConfig {
+  return config
+}

package/app/composables/contacts/createContact.js

@@ -0,0 +1,64 @@
+// composables/createContact.js
+import { createItem } from '@directus/sdk';
+
+export default async function createContact(contactData) {
+    const route = useRoute();
+
+    const id = route.params.id;
+    const { $directus } = useNuxtApp();
+  
+    try {
+      const contact = await $directus.request(createItem('contacts', [
+        {
+          first_name: contactData.first_name,
+          last_name: contactData.last_name,
+          company: contactData.company,
+          department: contactData.department,
+          job_title: contactData.job_title,
+          email: contactData.email,
+          phone: contactData.phone,
+          street: contactData.street,
+          postcode: contactData.postcode,
+          address_two: contactData.address_two,
+          po_box: contactData.po_box,
+          city: contactData.city,
+          state: contactData.state,
+          country: contactData.country,
+          label: contactData.label,
+          birthday: contactData.birthday,
+          notes: contactData.notes,
+          website: contactData.website,
+          related_person: contactData.related_person,
+          middle_name: contactData.middle_name,
+          prefix: contactData.prefix,
+          suffix: contactData.suffix,
+          nickname: contactData.nickname,
+          file_as: contactData.file_as,
+          phonetic_first: contactData.phonetic_first,
+          phonetic_middle: contactData.phonetic_middle,
+          phonetic_last: contactData.phonetic_last,
+          favorite: contactData.favorite,
+          image: contactData.image,
+          media: contactData.media,
+          audio: contactData.audio,
+          video: contactData.video,
+          document: contactData.document,
+          coverFile: null,
+          avatarFile: null,
+          username: contactData.username,
+          spaces: [
+            {
+                spaces_id: {
+                    id: id
+                }
+            }
+        ],
+        }
+      ]));
+      return contact;
+    } catch (error) {
+      console.error('Error creating contact:', error);
+      throw error;
+    }
+  }
+  

package/app/composables/contacts/deleteContact.js

@@ -0,0 +1,15 @@
+// composables/deleteContact.js
+import { deleteItem } from '@directus/sdk';
+
+export default async function deleteContact(contactId) {
+    const { $directus } = useNuxtApp();
+  
+    try {
+      $directus.request(deleteItem('contacts', contactId));
+      console.log('Contact deleted successfully');
+    } catch (error) {
+      console.error('Error deleting contact:', error);
+      throw error;
+    }
+  }
+  

package/app/composables/contacts/updateContact.js

@@ -0,0 +1,15 @@
+// composables/updateContact.js
+import { updateItem } from '@directus/sdk';
+
+export default async function updateContact(contactId, contactData) {
+    const { $directus } = useNuxtApp();
+  
+    try {
+      const contact = await $directus.request(updateItem('contacts', contactId));
+      return contact;
+    } catch (error) {
+      console.error('Error updating contact:', error);
+      throw error;
+    }
+  }
+  

package/app/composables/errors.ts

@@ -0,0 +1,16 @@
+export class SocialError extends Error {
+  constructor(message: string, public provider?: string, public cause?: any) {
+    super(message)
+    this.name = 'SocialError'
+  }
+}
+
+export class RateLimitError extends SocialError {
+  retryAfter?: number
+
+  constructor(message: string, provider?: string, retryAfter?: number, cause?: any) {
+    super(message, provider, cause)
+    this.name = 'RateLimitError'
+    this.retryAfter = retryAfter
+  }
+}

package/app/composables/metrics.ts

@@ -0,0 +1,52 @@
+export interface SocialMetrics {
+  requests: number
+  successes: number
+  failures: number
+  cacheHits: number
+  cacheMisses: number
+  backgroundRefreshes: number
+}
+
+const metrics = new Map<string, SocialMetrics>()
+
+function getProviderMetrics(provider: string): SocialMetrics {
+  if (!metrics.has(provider)) {
+    metrics.set(provider, {
+      requests: 0,
+      successes: 0,
+      failures: 0,
+      cacheHits: 0,
+      cacheMisses: 0,
+      backgroundRefreshes: 0
+    })
+  }
+  return metrics.get(provider)!
+}
+
+export function recordRequest(provider: string) {
+  getProviderMetrics(provider).requests++
+}
+
+export function recordSuccess(provider: string) {
+  getProviderMetrics(provider).successes++
+}
+
+export function recordFailure(provider: string) {
+  getProviderMetrics(provider).failures++
+}
+
+export function recordCacheHit(provider: string) {
+  getProviderMetrics(provider).cacheHits++
+}
+
+export function recordCacheMiss(provider: string) {
+  getProviderMetrics(provider).cacheMisses++
+}
+
+export function recordBackgroundRefresh(provider: string) {
+  getProviderMetrics(provider).backgroundRefreshes++
+}
+
+export function getMetrics(provider: string) {
+  return getProviderMetrics(provider)
+}

package/app/composables/posts/createPost.js

@@ -0,0 +1,40 @@
+// composables/createPost.js
+import { createItem } from '@directus/sdk';
+
+export default async function createPost(postData) {
+    const route = useRoute();
+
+    const id = route.params.id;
+    const { $directus } = useNuxtApp();
+  
+    try {
+      const post = await $directus.request(createItem('posts', [
+        {
+          title: postData.title,
+          content: postData.content,
+          status: postData.status,
+          type: postData.type,
+          image: postData.image,
+          media: postData.media,
+          audio: postData.audio,
+          video: postData.video,
+          document: postData.document,
+          coverFile: null,
+          avatarFile: null,
+          username: postData.username,
+          spaces: [
+            {
+                spaces_id: {
+                    id: id
+                }
+            }
+        ],
+        }
+      ]));
+      return post;
+    } catch (error) {
+      console.error('Error creating post:', error);
+      throw error;
+    }
+  }
+  

package/app/composables/posts/deletePost.js

@@ -0,0 +1,15 @@
+// composables/deletePost.js
+import { deleteItem } from '@directus/sdk';
+
+export default async function deletePost(postId) {
+    const { $directus } = useNuxtApp();
+  
+    try {
+      $directus.request(deleteItem('posts', postId));
+      console.log('Post deleted successfully');
+    } catch (error) {
+      console.error('Error deleting post:', error);
+      throw error;
+    }
+  }
+  

package/app/composables/posts/updatePost.js

@@ -0,0 +1,15 @@
+// composables/updatePost.js
+import { updateItem } from '@directus/sdk';
+
+export default async function updatePost(postId, postData) {
+    const { $directus } = useNuxtApp();
+  
+    try {
+      const post = await $directus.request(updateItem('posts', postId));
+      return post;
+    } catch (error) {
+      console.error('Error updating post:', error);
+      throw error;
+    }
+  }
+  

package/app/composables/posts/usePosts.ts

@@ -0,0 +1,22 @@
+// composables/usePosts.ts
+import { AtpAgent } from '@atproto/api'
+
+export const usePosts = () => {
+  const config = useRuntimeConfig()
+  const agent = new AtpAgent({ service: `${config.public.atprotoPds}` })
+
+  const createPost = async (text: string, embed?: any, reply?: any) => {
+    return await agent.post({
+      text,
+      createdAt: new Date().toISOString(),
+      embed,
+      reply
+    })
+  }
+
+  const getTimeline = async (limit = 20) => {
+    return await agent.getTimeline({ limit })
+  }
+
+  return { createPost, getTimeline }
+}

package/app/composables/providers/atproto.ts

@@ -0,0 +1,75 @@
+import { wrapSocialRequest } from '../utils'
+import { getSocialConfig } from '../config'
+import { registerSocialProvider } from '../registry'
+
+async function atprotoFetch(path: string, options: RequestInit = {}) {
+  const { baseUrl, apiKey } = getSocialConfig()
+  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 AtprotoProvider = {
+  async getProfile(handle: string) {
+    return wrapSocialRequest(
+      'atproto',
+      async () => {
+        const data = await atprotoFetch(`/xrpc/app.bsky.actor.getProfile?actor=${handle}`)
+        return {
+          id: data.did,
+          username: data.handle,
+          displayName: data.displayName,
+          avatarUrl: data.avatar,
+          url: `https://bsky.app/profile/${data.handle}`
+        }
+      },
+      {
+        cacheKey: `atproto:profile:${handle}`,
+        ttlMs: 1000 * 60 * 5, // 5 minutes
+        retry: true
+      }
+    )
+  },
+
+  async listPosts(handle: string) {
+    return wrapSocialRequest(
+      'atproto',
+      async () => {
+        const data = await atprotoFetch(`/xrpc/app.bsky.feed.getAuthorFeed?actor=${handle}`)
+        return (data.feed || []).map((item: any) => ({
+          id: item.post.uri,
+          content: item.post.record?.text,
+          createdAt: item.post.record?.createdAt,
+          author: {
+            id: item.post.author.did,
+            username: item.post.author.handle,
+            displayName: item.post.author.displayName,
+            avatarUrl: item.post.author.avatar
+          },
+          url: `https://bsky.app/profile/${item.post.author.handle}/post/${item.post.uri}`
+        }))
+      },
+      {
+        cacheKey: `atproto:posts:${handle}`,
+        ttlMs: 1000 * 30, // 30 seconds
+        retry: true
+      }
+    )
+  }
+}
+
+registerSocialProvider('atproto', AtprotoProvider)

package/app/composables/providers/mastodon.ts

@@ -0,0 +1,45 @@
+// src/providers/mastodon.ts
+import type { SocialProvider, SocialProfile, SocialPost } from '../types'
+import { registerSocialProvider } from '../registry'
+import { getSocialConfig } from '../config'
+
+async function mastodonFetch(path: string, options: RequestInit = {}) {
+  const { baseUrl, apiKey } = getSocialConfig()
+  const res = await fetch(`${baseUrl}${path}`, {
+    ...options,
+    headers: {
+      'Content-Type': 'application/json',
+      ...(apiKey ? { Authorization: `Bearer ${apiKey}` } : {}),
+      ...(options.headers || {})
+    }
+  })
+  if (!res.ok) throw new Error(`Mastodon error: ${res.status}`)
+  return res.json()
+}
+
+const MastodonProvider: SocialProvider = {
+  async getProfile(handle: string): Promise<SocialProfile> {
+    const data = await mastodonFetch(`/api/v1/accounts/lookup?acct=${handle}`)
+    return {
+      id: data.id,
+      username: data.acct,
+      displayName: data.display_name,
+      avatarUrl: data.avatar,
+      url: data.url
+    }
+  },
+
+  async listPosts(handle: string): Promise<SocialPost[]> {
+    const profile = await this.getProfile(handle)
+    const data = await mastodonFetch(`/api/v1/accounts/${profile.id}/statuses`)
+    return data.map((status: any) => ({
+      id: status.id,
+      content: status.content,
+      createdAt: status.created_at,
+      author: profile,
+      url: status.url
+    }))
+  }
+}
+
+registerSocialProvider('mastodon', MastodonProvider)

package/app/composables/rateLimit.ts

@@ -0,0 +1,41 @@
+import { RateLimitError } from "./errors";
+
+export interface RateLimitConfig {
+  maxRequests: number
+  windowMs: number
+}
+
+const providerLimits = new Map<string, RateLimitConfig>()
+const providerUsage = new Map<string, { count: number; resetAt: number }>()
+
+export function setRateLimit(provider: string, config: RateLimitConfig) {
+  providerLimits.set(provider, config)
+}
+
+export function checkRateLimit(provider: string) {
+  const limit = providerLimits.get(provider)
+  if (!limit) return
+
+  const now = Date.now()
+  const usage = providerUsage.get(provider) || {
+    count: 0,
+    resetAt: now + limit.windowMs
+  }
+
+  if (now > usage.resetAt) {
+    usage.count = 0
+    usage.resetAt = now + limit.windowMs
+  }
+
+  usage.count++
+
+  providerUsage.set(provider, usage)
+
+  if (usage.count > limit.maxRequests) {
+    throw new RateLimitError(
+      `Meeovi internal rate limit exceeded for provider "${provider}"`,
+      provider,
+      Math.ceil((usage.resetAt - now) / 1000)
+    )
+  }
+}

package/app/composables/registry.ts

@@ -0,0 +1,13 @@
+import type { SocialProvider } from './types'
+
+const providers: Record<string, SocialProvider> = {}
+
+export function registerSocialProvider(name: string, provider: SocialProvider) {
+  providers[name] = provider
+}
+
+export function getSocialProvider(name: string): SocialProvider {
+  const provider = providers[name]
+  if (!provider) throw new Error(`Social provider "${name}" not found`)
+  return provider
+}

package/app/composables/retry.ts

@@ -0,0 +1,40 @@
+export interface RetryOptions {
+  retries: number
+  baseDelayMs: number
+  maxDelayMs: number
+}
+
+const defaultRetry: RetryOptions = {
+  retries: 3,
+  baseDelayMs: 300,
+  maxDelayMs: 5000
+}
+
+function sleep(ms: number) {
+  return new Promise((resolve) => setTimeout(resolve, ms))
+}
+
+export async function withRetry<T>(
+  fn: () => Promise<T>,
+  opts: Partial<RetryOptions> = {}
+): Promise<T> {
+  const { retries, baseDelayMs, maxDelayMs } = { ...defaultRetry, ...opts }
+
+  let attempt = 0
+
+  while (true) {
+    try {
+      return await fn()
+    } catch (err: any) {
+      attempt++
+      if (attempt > retries) throw err
+
+      const delay = Math.min(
+        baseDelayMs * Math.pow(2, attempt) + Math.random() * 100,
+        maxDelayMs
+      )
+
+      await sleep(delay)
+    }
+  }
+}