@artisan-cloud/plugin-framework-admin 0.0.1-alpha → 0.0.2-alpha

package/index.ts

@@ -4,13 +4,27 @@ export interface PowerXAdminConfigOptions {
 }
 
 export function definePowerXAdminConfig(options: PowerXAdminConfigOptions) {
+  const pluginId = options.pluginId
+  const inferredApiBase =
+    process.env.NUXT_PUBLIC_POWERX_API_BASE?.trim() || `/_p/${pluginId}/api/v1`
+  const inferredCapabilityEndpoint =
+    process.env.NUXT_PUBLIC_POWERX_CAPABILITY_ENDPOINT?.trim() || '/integration/capabilities/invoke'
+
   return {
     extends: ['@artisan-cloud/plugin-framework-admin/layer'],
     appConfig: {
       powerx: {
-        pluginId: options.pluginId,
+        pluginId,
         starterPages: options.starterPages ?? true
       }
+    },
+    runtimeConfig: {
+      public: {
+        powerx: {
+          apiBase: inferredApiBase,
+          capabilityEndpoint: inferredCapabilityEndpoint
+        }
+      }
     }
   }
 }

package/layer/app/composables/usePowerXCapability.ts

@@ -0,0 +1,40 @@
+import { useNuxtApp } from '#app'
+import type {
+  PowerXCapabilityBridge,
+  PowerXCapabilityRequest,
+  PowerXCapabilityResponse
+} from '../plugins/powerx-capability.client'
+
+export interface UsePowerXCapabilityOptions extends Partial<Omit<PowerXCapabilityRequest, 'capabilityId' | 'action' | 'payload'>> {
+  payload?: Record<string, any> | null
+}
+
+export type UsePowerXCapabilityInvoker = (
+  capabilityId: string,
+  action: string,
+  payload?: Record<string, any> | null,
+  options?: UsePowerXCapabilityOptions
+) => Promise<PowerXCapabilityResponse>
+
+export const usePowerXCapability = (bridge?: PowerXCapabilityBridge): UsePowerXCapabilityInvoker => {
+  const nuxtApp = useNuxtApp()
+  const client = bridge ?? nuxtApp.$powerxCapability
+  if (!client) {
+    throw new Error('PowerX capability bridge is not initialized. Ensure the powerx-capability plugin is registered.')
+  }
+
+  return async (capabilityId, action, payload, options) => {
+    const mergedPayload = options?.payload ?? payload ?? {}
+
+    return client.invoke({
+      capabilityId,
+      action,
+      payload: mergedPayload,
+      headers: options?.headers,
+      requestId: options?.requestId,
+      signal: options?.signal,
+      apiBase: options?.apiBase,
+      endpoint: options?.endpoint
+    })
+  }
+}

package/layer/app/plugins/powerx-capability.client.ts

@@ -0,0 +1,142 @@
+import { useRuntimeConfig } from '#imports'
+import { ofetch, type OFetch, type FetchResponse } from 'ofetch'
+
+const DEFAULT_ENDPOINT = '/integration/capabilities/invoke'
+
+export interface PowerXCapabilityRequest {
+  capabilityId: string
+  action: string
+  payload?: Record<string, any> | null
+  headers?: Record<string, string>
+  requestId?: string
+  signal?: AbortSignal
+  apiBase?: string
+  endpoint?: string
+}
+
+export interface PowerXCapabilityResponse {
+  traceId?: string
+  status?: string
+  data?: Record<string, any> | null
+  errors?: Record<string, any> | Record<string, any>[] | null
+}
+
+export class PowerXCapabilityBridgeError extends Error {
+  status?: number
+  traceId?: string
+  details?: any
+
+  constructor(message: string, opts: { status?: number; traceId?: string; details?: any } = {}) {
+    super(message)
+    this.name = 'PowerXCapabilityBridgeError'
+    this.status = opts.status
+    this.traceId = opts.traceId
+    this.details = opts.details
+  }
+}
+
+export interface PowerXCapabilityBridge {
+  invoke(request: PowerXCapabilityRequest): Promise<PowerXCapabilityResponse>
+}
+
+interface BridgeOptions {
+  apiBase?: string
+  endpoint?: string
+  fetcher?: OFetch
+}
+
+const combineURL = (base?: string, endpoint?: string) => {
+  const normalizedBase = (base || '').replace(/\/+$/, '')
+  const normalizedEndpoint = ('/' + (endpoint || '').replace(/^\/+/, '')).replace(/\/{2,}/g, '/')
+  if (!normalizedBase) {
+    return normalizedEndpoint
+  }
+  return `${normalizedBase}${normalizedEndpoint}`
+}
+
+const createBridge = (options: BridgeOptions): PowerXCapabilityBridge => {
+  const fetcher = options.fetcher ?? ofetch
+  const endpoint = options.endpoint || DEFAULT_ENDPOINT
+  return {
+    async invoke(request) {
+      const capabilityId = request.capabilityId?.trim()
+      if (!capabilityId) {
+        throw new PowerXCapabilityBridgeError('capabilityId is required')
+      }
+      const action = request.action?.trim()
+      if (!action) {
+        throw new PowerXCapabilityBridgeError('action is required')
+      }
+      const url = combineURL(request.apiBase ?? options.apiBase, request.endpoint ?? endpoint)
+      const headers: Record<string, string> = {
+        'Content-Type': 'application/json',
+        ...request.headers
+      }
+      if (request.requestId && !headers['X-Request-ID']) {
+        headers['X-Request-ID'] = request.requestId
+      }
+      let response: FetchResponse<Record<string, any>>
+      try {
+        response = await fetcher.raw(url, {
+          method: 'POST',
+          headers,
+          body: {
+            capabilityId,
+            action,
+            payload: request.payload ?? {}
+          },
+          signal: request.signal
+        })
+      } catch (error) {
+        throw new PowerXCapabilityBridgeError(error instanceof Error ? error.message : 'capability invoke failed')
+      }
+
+      const payload = response._data ?? {}
+      const traceId = payload.traceId || response.headers.get('x-trace-id') || undefined
+      if (response.status >= 400 || payload.error) {
+        throw new PowerXCapabilityBridgeError(payload.error?.message || 'capability invoke failed', {
+          status: response.status,
+          traceId,
+          details: payload.error || payload.errors
+        })
+      }
+
+      return {
+        traceId,
+        status: payload.status,
+        data: payload.data ?? null,
+        errors: payload.errors ?? null
+      }
+    }
+  }
+}
+
+export default defineNuxtPlugin((nuxtApp) => {
+  const runtimeConfig = useRuntimeConfig()
+  const publicConfig = runtimeConfig?.public as Record<string, any> | undefined
+  const powerxConfig = (publicConfig?.powerx ?? {}) as Record<string, any>
+
+  const bridge = createBridge({
+    apiBase: (powerxConfig.apiBase as string | undefined) ?? '',
+    endpoint: (powerxConfig.capabilityEndpoint as string | undefined) ?? DEFAULT_ENDPOINT,
+    fetcher: nuxtApp.$fetch
+  })
+
+  return {
+    provide: {
+      powerxCapability: bridge
+    }
+  }
+})
+
+declare module '#app' {
+  interface NuxtApp {
+    $powerxCapability: PowerXCapabilityBridge
+  }
+}
+
+declare module 'vue' {
+  interface ComponentCustomProperties {
+    $powerxCapability: PowerXCapabilityBridge
+  }
+}

package/layer/nuxt.config.ts

@@ -6,6 +6,14 @@ const layerDir = dirname(fileURLToPath(import.meta.url))
 const appDir = resolve(layerDir, 'app')
 
 const config: NuxtConfig = {
+  runtimeConfig: {
+    public: {
+      powerx: {
+        apiBase: process.env.NUXT_PUBLIC_POWERX_API_BASE ?? '',
+        capabilityEndpoint: process.env.NUXT_PUBLIC_POWERX_CAPABILITY_ENDPOINT ?? '/integration/capabilities/invoke'
+      }
+    }
+  },
   imports: {
     dirs: [
       resolve(appDir, 'composables'),
@@ -35,3 +43,12 @@ const config: NuxtConfig = {
 }
 
 export default config
+
+declare module 'nuxt/schema' {
+  interface PublicRuntimeConfig {
+    powerx: {
+      apiBase: string
+      capabilityEndpoint: string
+    }
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@artisan-cloud/plugin-framework-admin",
-  "version": "0.0.1-alpha",
+  "version": "0.0.2-alpha",
   "type": "module",
   "exports": {
     ".": "./index.ts",