@meeovi/api 1.0.0

package/index.ts

@@ -0,0 +1,24 @@
+import { loadGraphQL } from './src/loader/loadGraphql'
+
+loadGraphQL() 
+
+export * from './src/utils/fetcher' 
+export * from './src/loader/registry'
+
+// Apollo client
+export * from './src/client/apollo'
+
+// REST helper
+export * from './src/client/rest'
+
+// GraphQL queries/mutations
+export * from './src/graphql/queries/products'
+export * from './src/graphql/mutations/cart'
+
+// Providers
+export * from './src/providers/commerce'
+export * from './src/providers/content'
+export * from './src/providers/search'
+
+// Utils
+export * from './src/utils/errors'

package/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "@meeovi/api",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.js",
+  "exports": { ".": "./index.ts" },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "type": "commonjs",
+  "dependencies": {
+    "@apollo/client": "^4.1.0",
+    "cross-fetch": "^4.1.0",
+    "graphql": "^16.12.0",
+    "graphql-tag": "^2.12.6"
+  }
+}

package/src/client/apollo.ts

@@ -0,0 +1,20 @@
+import { ApolloClient, InMemoryCache, HttpLink } from '@apollo/client'
+import fetch from 'cross-fetch'
+
+let client: ApolloClient | null = null
+
+export function createApolloClient(uri: string) {
+  client = new ApolloClient({
+    link: new HttpLink({ uri, fetch }),
+    cache: new InMemoryCache()
+  })
+
+  return client
+}
+
+export function getApolloClient() {
+  if (!client) {
+    throw new Error('Apollo client not initialized. Call createApolloClient() first.')
+  }
+  return client
+}

package/src/client/rest.ts

@@ -0,0 +1,5 @@
+export async function apiFetch(url: string, options: RequestInit = {}) {
+  const res = await fetch(url, options)
+  if (!res.ok) throw new Error(`API error: ${res.status}`)
+  return res.json()
+}

package/src/fetcher/fetcherRegistry.ts

@@ -0,0 +1,18 @@
+import type { Fetcher } from './types'
+
+const fetchers: Record<string, Fetcher> = {}
+let activeFetcherName: string | null = null
+
+export function registerFetcher(name: string, fetcher: Fetcher) {
+  fetchers[name] = fetcher
+}
+
+export function setActiveFetcher(name: string) {
+  if (!fetchers[name]) throw new Error(`Fetcher "${name}" not registered`)
+  activeFetcherName = name
+}
+
+export function getFetcher(): Fetcher {
+  if (!activeFetcherName) throw new Error('No active fetcher set')
+  return fetchers[activeFetcherName]
+}

package/src/fetcher/graphql.ts

@@ -0,0 +1,19 @@
+
+import { getApolloClient } from '../client/apollo'
+import { Fetcher, FetcherRequest, FetcherResponse } from './types'
+
+export const GraphQLFetcher: Fetcher = {
+  async execute<T = any>(req: FetcherRequest): Promise<FetcherResponse<T>> {
+    try {
+      const client = getApolloClient()
+      const { data } = await client.query({
+        query: req.operation,
+        variables: req.variables || {}
+      })
+
+      return { data }
+    } catch (error) {
+      return { error }
+    }
+  }
+}

package/src/fetcher/registry.ts

@@ -0,0 +1,15 @@
+
+import { Fetcher } from './types'
+
+let activeFetcher: Fetcher | null = null
+
+export function setFetcher(fetcher: Fetcher) {
+  activeFetcher = fetcher
+}
+
+export function getFetcher(): Fetcher {
+  if (!activeFetcher) {
+    throw new Error('No fetcher has been set. Call setFetcher() first.')
+  }
+  return activeFetcher
+}

package/src/fetcher/rest.ts

@@ -0,0 +1,19 @@
+
+import { Fetcher, FetcherRequest, FetcherResponse } from './types'
+
+export const RestFetcher: Fetcher = {
+  async execute<T = any>(req: FetcherRequest): Promise<FetcherResponse<T>> {
+    try {
+      const res = await fetch(req.operation, {
+        method: req.options?.method || 'GET',
+        headers: req.options?.headers,
+        body: req.options?.body ? JSON.stringify(req.options.body) : undefined
+      })
+
+      const data = await res.json()
+      return { data }
+    } catch (error) {
+      return { error }
+    }
+  }
+}

package/src/fetcher/types.ts

@@ -0,0 +1,15 @@
+
+export interface FetcherRequest {
+  operation: string
+  variables?: Record<string, any>
+  options?: Record<string, any>
+}
+
+export interface FetcherResponse<T = any> {
+  data?: T
+  error?: any
+}
+
+export interface Fetcher {
+  execute<T = any>(req: FetcherRequest): Promise<FetcherResponse<T>>
+}

package/src/graphql/queries/products.ts

@@ -0,0 +1,24 @@
+import { gql } from 'graphql-tag'
+
+export const GET_PRODUCT = gql`
+  query GetProduct($id: ID!) {
+    product(id: $id) {
+      id
+      title
+      description
+      price
+      images
+    }
+  }
+`
+
+export const LIST_PRODUCTS = gql`
+  query ListProducts {
+    products {
+      id
+      title
+      price
+      images
+    }
+  }
+`

package/src/loader/loadGraphQLNamespaced.ts

@@ -0,0 +1,49 @@
+import {
+  registerNamespacedQuery,
+  registerNamespacedMutation,
+  registerNamespacedSubscription
+} from './nsRegistry'
+
+export function loadGraphQLNamespaced() {
+  // queries
+  const queryModules = (import.meta as any).glob('../graphql/queries/**/*.ts', { eager: true })
+  for (const path in queryModules) {
+    const mod = queryModules[path] as Record<string, any>
+    const namespace = path
+      .replace('../graphql/queries/', '')
+      .replace('.ts', '')
+      .replace(/\//g, '.')
+
+    for (const key in mod) {
+      registerNamespacedQuery(namespace, key, mod[key])
+    }
+  }
+
+  // mutations
+  const mutationModules = (import.meta as any).glob('../graphql/mutations/**/*.ts', { eager: true })
+  for (const path in mutationModules) {
+    const mod = mutationModules[path] as Record<string, any>
+    const namespace = path
+      .replace('../graphql/mutations/', '')
+      .replace('.ts', '')
+      .replace(/\//g, '.')
+
+    for (const key in mod) {
+      registerNamespacedMutation(namespace, key, mod[key])
+    }
+  }
+
+  // subscriptions
+  const subscriptionModules = (import.meta as any).glob('../graphql/subscriptions/**/*.ts', { eager: true })
+  for (const path in subscriptionModules) {
+    const mod = subscriptionModules[path] as Record<string, any>
+    const namespace = path
+      .replace('../graphql/subscriptions/', '')
+      .replace('.ts', '')
+      .replace(/\//g, '.')
+
+    for (const key in mod) {
+      registerNamespacedSubscription(namespace, key, mod[key])
+    }
+  }
+}

package/src/loader/loadGraphql.ts

@@ -0,0 +1,34 @@
+import {
+  registerQuery,
+  registerMutation,
+  registerSubscription
+} from './registry'
+
+export function loadGraphQL() {
+  // Load queries
+  const queryModules = (import.meta as any).glob('../graphql/queries/*.ts', { eager: true })
+  for (const path in queryModules) {
+    const mod = queryModules[path]
+    for (const key in mod) {
+      registerQuery(key, mod[key])
+    }
+  }
+
+  // Load mutations
+  const mutationModules = (import.meta as any).glob('../graphql/mutations/*.ts', { eager: true })
+  for (const path in mutationModules) {
+    const mod = mutationModules[path]
+    for (const key in mod) {
+      registerMutation(key, mod[key])
+    }
+  }
+
+  // Load subscriptions
+  const subscriptionModules = (import.meta as any).glob('../graphql/subscriptions/*.ts', { eager: true })
+  for (const path in subscriptionModules) {
+    const mod = subscriptionModules[path]
+    for (const key in mod) {
+      registerSubscription(key, mod[key])
+    }
+  }
+}

package/src/loader/loadRest.ts

@@ -0,0 +1,13 @@
+import { registerRestEndpoint } from '../rest/registry'
+import type { RestEndpoint } from '../rest/types'
+
+export function loadRest() {
+  const modules = (import.meta as any).glob('../rest/*.ts', { eager: true })
+
+  for (const path in modules) {
+    const mod = modules[path] as Record<string, RestEndpoint>
+    for (const key in mod) {
+      registerRestEndpoint(key, mod[key])
+    }
+  }
+}

package/src/loader/nsRegistry.ts

@@ -0,0 +1,54 @@
+type OperationMap = Record<string, any>
+
+const queries: OperationMap = {}
+const mutations: OperationMap = {}
+const subscriptions: OperationMap = {}
+
+function setNested(map: OperationMap, ns: string, value: any) {
+  const parts = ns.split('.')
+  let current = map
+
+  for (let i = 0; i < parts.length - 1; i++) {
+    const part = parts[i]
+    current[part] = current[part] || {}
+    current = current[part]
+  }
+
+  current[parts[parts.length - 1]] = value
+}
+
+function getNested(map: OperationMap, ns: string) {
+  const parts = ns.split('.')
+  let current: any = map
+
+  for (const part of parts) {
+    current = current?.[part]
+    if (!current) return undefined
+  }
+
+  return current
+}
+
+export function registerNamespacedQuery(namespace: string, name: string, op: any) {
+  setNested(queries, `${namespace}.${name}`, op)
+}
+
+export function registerNamespacedMutation(namespace: string, name: string, op: any) {
+  setNested(mutations, `${namespace}.${name}`, op)
+}
+
+export function registerNamespacedSubscription(namespace: string, name: string, op: any) {
+  setNested(subscriptions, `${namespace}.${name}`, op)
+}
+
+export function getQuery(ns: string) {
+  return getNested(queries, ns)
+}
+
+export function getMutation(ns: string) {
+  return getNested(mutations, ns)
+}
+
+export function getSubscription(ns: string) {
+  return getNested(subscriptions, ns)
+}

package/src/loader/registry.ts

@@ -0,0 +1,27 @@
+const queries: Record<string, any> = {}
+const mutations: Record<string, any> = {}
+const subscriptions: Record<string, any> = {}
+
+export function registerQuery(name: string, operation: any) {
+  queries[name] = operation
+}
+
+export function registerMutation(name: string, operation: any) {
+  mutations[name] = operation
+}
+
+export function registerSubscription(name: string, operation: any) {
+  subscriptions[name] = operation
+}
+
+export function getQuery(name: string) {
+  return queries[name]
+}
+
+export function getMutation(name: string) {
+  return mutations[name]
+}
+
+export function getSubscription(name: string) {
+  return subscriptions[name]
+}

package/src/plugins/index.ts

@@ -0,0 +1,13 @@
+import type { ApiPluginContext } from './types'
+import { registerFetcher, setActiveFetcher } from '../fetcher/fetcherRegistry'
+
+export type ApiPlugin = (ctx: ApiPluginContext) => void
+
+export function defineApiPlugin(plugin: ApiPlugin) {
+  const ctx: ApiPluginContext = {
+    registerFetcher,
+    setActiveFetcher
+  }
+
+  plugin(ctx)
+}

package/src/plugins/types.ts

@@ -0,0 +1,5 @@
+export interface ApiPluginContext {
+  registerFetcher: (name: string, fetcher: any) => void
+  setActiveFetcher: (name: string) => void
+  // you can add more hooks later (registerRestEndpoint, etc.)
+}

package/src/providers/commerce.ts

@@ -0,0 +1,21 @@
+import { getApolloClient } from '../client/apollo'
+import { GET_PRODUCT, LIST_PRODUCTS } from '../graphql/queries/products'
+
+export const MeeoviApiCommerceProvider = {
+  async getProduct(id: string) {
+    const client = getApolloClient()
+    const { data } = await client.query({
+      query: GET_PRODUCT,
+      variables: { id }
+    })
+    return data.product
+  },
+
+  async listProducts() {
+    const client = getApolloClient()
+    const { data } = await client.query({
+      query: LIST_PRODUCTS
+    })
+    return data.products
+  }
+}

package/src/rest/registry.ts

@@ -0,0 +1,11 @@
+import { RestEndpoint } from "./types"
+
+const restEndpoints: Record<string, RestEndpoint> = {}
+
+export function registerRestEndpoint(name: string, endpoint: RestEndpoint) {
+  restEndpoints[name] = endpoint
+}
+
+export function getRestEndpoint(name: string): RestEndpoint | undefined {
+  return restEndpoints[name]
+}

package/src/rest/types.ts

@@ -0,0 +1,5 @@
+export interface RestEndpoint {
+  url: string
+  method?: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE'
+  headers?: Record<string, string>
+}

package/src/utils/errors.ts

@@ -0,0 +1,6 @@
+export class ApiError extends Error {
+  constructor(message: string, public status?: number) {
+    super(message)
+    this.name = 'ApiError'
+  }
+}

package/src/utils/fetcher.ts

@@ -0,0 +1,17 @@
+
+import { getFetcher } from '../fetcher/registry'
+import { FetcherRequest, FetcherResponse } from '../fetcher/types'
+
+export async function fetcher<T = any>(
+  operation: string,
+  variables?: Record<string, any>,
+  options?: Record<string, any>
+): Promise<FetcherResponse<T>> {
+  const activeFetcher = getFetcher()
+
+  return activeFetcher.execute<T>({
+    operation,
+    variables,
+    options
+  })
+}