feat(client): add scoped routes and expand runtime API surface

Author: EvanSchleret

README.md

@@ -1,8 +1,18 @@
 import { addComponent, addImports, addPlugin, addTypeTemplate, createResolver, defineNuxtModule } from '@nuxt/kit'
-import type { FormForgeClientConfig, FormForgeDatetimeMode, FormForgeUploadMode } from './runtime/types'
+import type {
+  FormForgeClientConfig,
+  FormForgeDatetimeMode,
+  FormForgeScopedRouteMap,
+  FormForgeScopeParams,
+  FormForgeUploadMode
+} from './runtime/types'
 
 export interface ModuleOptions {
   baseURL?: string
+  baseURLParams?: Record<string, string | number | undefined>
+  scopedRoutes?: FormForgeScopedRouteMap
+  defaultScope?: string
+  scopeParams?: FormForgeScopeParams
   credentials?: RequestCredentials
   headers?: Record<string, string>
   uploadMode?: FormForgeUploadMode
@@ -21,6 +31,9 @@ export default defineNuxtModule<ModuleOptions>({
   },
   defaults: {
     baseURL: '/api/formforge/v1',
+    scopedRoutes: {},
+    defaultScope: undefined,
+    scopeParams: {},
     credentials: 'include',
     headers: {},
     uploadMode: 'staged',
@@ -36,6 +49,10 @@ export default defineNuxtModule<ModuleOptions>({
     nuxt.options.runtimeConfig.public.formforge = {
       ...runtimeConfig,
       baseURL: options.baseURL,
+      baseURLParams: options.baseURLParams,
+      scopedRoutes: options.scopedRoutes,
+      defaultScope: options.defaultScope,
+      scopeParams: options.scopeParams,
       credentials: options.credentials,
       headers: options.headers,
       uploadMode: options.uploadMode,
@@ -55,6 +72,16 @@ export default defineNuxtModule<ModuleOptions>({
       filePath: resolver.resolve('./runtime/renderers/default/FormForgeBuilder.vue')
     })
 
+    addComponent({
+      name: 'FormForgeResponse',
+      filePath: resolver.resolve('./runtime/renderers/default/FormForgeResponse.vue')
+    })
+
+    addComponent({
+      name: 'FormForgeCategoryCreateModal',
+      filePath: resolver.resolve('./runtime/renderers/default/FormForgeCategoryCreateModal.vue')
+    })
+
     if (options.autoImports === true) {
       addImports([
         { from: resolver.resolve('./runtime/composables/useFormForgeApi'), name: 'useFormForgeApi' },
@@ -69,6 +96,8 @@ export default defineNuxtModule<ModuleOptions>({
         { from: resolver.resolve('./runtime/composables/useFormForgeSubmit'), name: 'useFormForgeSubmit' },
         { from: resolver.resolve('./runtime/composables/useFormForgeSubmission'), name: 'useFormForgeSubmission' },
         { from: resolver.resolve('./runtime/composables/useFormForgeResponses'), name: 'useFormForgeResponses' },
+        { from: resolver.resolve('./runtime/composables/useFormForgeCategory'), name: 'useFormForgeCategory' },
+        { from: resolver.resolve('./runtime/composables/useFormForgeCategory'), name: 'useFormForgeCategoryOptions' },
         { from: resolver.resolve('./runtime/composables/useFormForgeManagement'), name: 'useFormForgeManagement' },
         { from: resolver.resolve('./runtime/composables/useFormForgeWizard'), name: 'useFormForgeWizard' },
         { from: resolver.resolve('./runtime/composables/useFormForgeBuilder'), name: 'useFormForgeBuilder' }

src/module.ts

@@ -0,0 +1,131 @@
+import type {
+  FormForgeCategory,
+  FormForgeCategoryCreateInput,
+  FormForgeCategoryListQuery,
+  FormForgeCategoryListResponse,
+  FormForgeCategoryUpdateInput,
+  FormForgeHttpAdapter,
+  FormForgeJsonObject
+} from '../types'
+import type { FormForgeMutationOptions } from './management'
+import { normalizeFormForgeCategory, normalizeFormForgeCategoryListResponse } from '../utils/category'
+import { pickFormForgeDataEnvelope } from '../utils/object'
+import { resolveEndpointPath, type FormForgeRequestOptions } from './request'
+
+function withMutationHeaders(options: FormForgeMutationOptions = {}): Record<string, string> {
+  if (options.idempotencyKey === undefined || options.idempotencyKey === '') {
+    return {}
+  }
+
+  return {
+    'Idempotency-Key': options.idempotencyKey
+  }
+}
+
+function toJsonObject(input: FormForgeCategoryCreateInput | FormForgeCategoryUpdateInput): FormForgeJsonObject {
+  return JSON.parse(JSON.stringify(input)) as FormForgeJsonObject
+}
+
+function normalizeSingleCategory(payload: FormForgeJsonObject): FormForgeCategory {
+  const dataEnvelope = pickFormForgeDataEnvelope(payload)
+  const normalized = normalizeFormForgeCategory(dataEnvelope)
+
+  if (normalized !== null) {
+    return normalized
+  }
+
+  return {
+    id: 0,
+    key: '',
+    name: '',
+    description: null,
+    is_active: false,
+    meta: {},
+    created_at: null,
+    updated_at: null
+  }
+}
+
+export async function fetchFormForgeCategories(
+  http: FormForgeHttpAdapter,
+  query: FormForgeCategoryListQuery = {},
+  options: FormForgeRequestOptions = {}
+): Promise<FormForgeCategoryListResponse> {
+  const resolvedQuery: Record<string, string | number | boolean | undefined> = {
+    per_page: query.per_page,
+    search: query.search,
+    is_active: query.is_active === undefined ? undefined : (query.is_active ? 1 : 0)
+  }
+
+  const response = await http<FormForgeJsonObject>({
+    path: resolveEndpointPath(options.endpoint, '/categories', {}, options.scope),
+    method: 'GET',
+    query: resolvedQuery
+  })
+
+  return normalizeFormForgeCategoryListResponse(response.data)
+}
+
+export async function fetchFormForgeCategory(
+  http: FormForgeHttpAdapter,
+  categoryKey: string,
+  options: FormForgeRequestOptions = {}
+): Promise<FormForgeCategory> {
+  const response = await http<FormForgeJsonObject>({
+    path: resolveEndpointPath(options.endpoint, `/categories/${categoryKey}`, {
+      categoryKey
+    }, options.scope),
+    method: 'GET'
+  })
+
+  return normalizeSingleCategory(response.data)
+}
+
+export async function createFormForgeCategory(
+  http: FormForgeHttpAdapter,
+  input: FormForgeCategoryCreateInput,
+  options: FormForgeMutationOptions = {}
+): Promise<FormForgeCategory> {
+  const response = await http<FormForgeJsonObject>({
+    path: resolveEndpointPath(options.endpoint, '/categories', {}, options.scope),
+    method: 'POST',
+    headers: withMutationHeaders(options),
+    json: toJsonObject(input)
+  })
+
+  return normalizeSingleCategory(response.data)
+}
+
+export async function patchFormForgeCategory(
+  http: FormForgeHttpAdapter,
+  categoryKey: string,
+  input: FormForgeCategoryUpdateInput,
+  options: FormForgeMutationOptions = {}
+): Promise<FormForgeCategory> {
+  const response = await http<FormForgeJsonObject>({
+    path: resolveEndpointPath(options.endpoint, `/categories/${categoryKey}`, {
+      categoryKey
+    }, options.scope),
+    method: 'PATCH',
+    headers: withMutationHeaders(options),
+    json: toJsonObject(input)
+  })
+
+  return normalizeSingleCategory(response.data)
+}
+
+export async function deleteFormForgeCategory(
+  http: FormForgeHttpAdapter,
+  categoryKey: string,
+  options: FormForgeMutationOptions = {}
+): Promise<FormForgeCategory> {
+  const response = await http<FormForgeJsonObject>({
+    path: resolveEndpointPath(options.endpoint, `/categories/${categoryKey}`, {
+      categoryKey
+    }, options.scope),
+    method: 'DELETE',
+    headers: withMutationHeaders(options)
+  })
+
+  return normalizeSingleCategory(response.data)
+}