@morscherlab/mint-sdk 1.0.0-rc.2 → 1.0.0-rc.5

package/src/composables/useFormValidation.ts

@@ -0,0 +1,154 @@
+/**
+ * Validation rule function type.
+ * Returns error message string if invalid, undefined/null if valid.
+ */
+export type ValidationRule<T = unknown> = (value: T, formData: Record<string, unknown>) => string | undefined | null
+
+/**
+ * Field validation rules configuration.
+ */
+export interface FieldRules<T = unknown> {
+  required?: boolean | string
+  minLength?: number | { value: number; message: string }
+  maxLength?: number | { value: number; message: string }
+  min?: number | { value: number; message: string }
+  max?: number | { value: number; message: string }
+  pattern?: RegExp | { value: RegExp; message: string }
+  email?: boolean | string
+  custom?: ValidationRule<T> | ValidationRule<T>[]
+}
+
+const validators = {
+  required: (value: unknown, message = 'This field is required'): string | null => {
+    if (value === null || value === undefined || value === '') {
+      return message
+    }
+    if (Array.isArray(value) && value.length === 0) {
+      return message
+    }
+    return null
+  },
+
+  minLength: (value: unknown, min: number, message?: string): string | null => {
+    if (typeof value !== 'string') return null
+    if (value.length < min) {
+      return message || `Must be at least ${min} characters`
+    }
+    return null
+  },
+
+  maxLength: (value: unknown, max: number, message?: string): string | null => {
+    if (typeof value !== 'string') return null
+    if (value.length > max) {
+      return message || `Must be at most ${max} characters`
+    }
+    return null
+  },
+
+  min: (value: unknown, min: number, message?: string): string | null => {
+    if (typeof value !== 'number') return null
+    if (value < min) {
+      return message || `Must be at least ${min}`
+    }
+    return null
+  },
+
+  max: (value: unknown, max: number, message?: string): string | null => {
+    if (typeof value !== 'number') return null
+    if (value > max) {
+      return message || `Must be at most ${max}`
+    }
+    return null
+  },
+
+  pattern: (value: unknown, pattern: RegExp, message?: string): string | null => {
+    if (typeof value !== 'string') return null
+    if (!pattern.test(value)) {
+      return message || 'Invalid format'
+    }
+    return null
+  },
+
+  email: (value: unknown, message = 'Invalid email address'): string | null => {
+    if (typeof value !== 'string' || !value) return null
+    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/
+    if (!emailRegex.test(value)) {
+      return message
+    }
+    return null
+  },
+}
+
+export function validateFieldValue(
+  value: unknown,
+  fieldRules: FieldRules | undefined,
+  formData: Record<string, unknown>,
+): string | null {
+  if (!fieldRules) return null
+
+  if (fieldRules.required) {
+    const message = typeof fieldRules.required === 'string' ? fieldRules.required : undefined
+    const error = validators.required(value, message)
+    if (error) return error
+  }
+
+  if (value === null || value === undefined || value === '') {
+    return null
+  }
+
+  if (fieldRules.minLength !== undefined) {
+    const config = typeof fieldRules.minLength === 'number'
+      ? { value: fieldRules.minLength, message: undefined }
+      : fieldRules.minLength
+    const error = validators.minLength(value, config.value, config.message)
+    if (error) return error
+  }
+
+  if (fieldRules.maxLength !== undefined) {
+    const config = typeof fieldRules.maxLength === 'number'
+      ? { value: fieldRules.maxLength, message: undefined }
+      : fieldRules.maxLength
+    const error = validators.maxLength(value, config.value, config.message)
+    if (error) return error
+  }
+
+  if (fieldRules.min !== undefined) {
+    const config = typeof fieldRules.min === 'number'
+      ? { value: fieldRules.min, message: undefined }
+      : fieldRules.min
+    const error = validators.min(value, config.value, config.message)
+    if (error) return error
+  }
+
+  if (fieldRules.max !== undefined) {
+    const config = typeof fieldRules.max === 'number'
+      ? { value: fieldRules.max, message: undefined }
+      : fieldRules.max
+    const error = validators.max(value, config.value, config.message)
+    if (error) return error
+  }
+
+  if (fieldRules.pattern !== undefined) {
+    const config = fieldRules.pattern instanceof RegExp
+      ? { value: fieldRules.pattern, message: undefined }
+      : fieldRules.pattern
+    const error = validators.pattern(value, config.value, config.message)
+    if (error) return error
+  }
+
+  if (fieldRules.email) {
+    const message = typeof fieldRules.email === 'string' ? fieldRules.email : undefined
+    const error = validators.email(value, message)
+    if (error) return error
+  }
+
+  if (fieldRules.custom) {
+    const customRules = Array.isArray(fieldRules.custom) ? fieldRules.custom : [fieldRules.custom]
+    for (const rule of customRules) {
+      const error = rule(value, formData)
+      if (error) return error
+    }
+  }
+
+  return null
+}

package/src/composables/usePluginClient.ts

@@ -7,8 +7,18 @@ import {
   getInjectedPlatformContext,
   resolveCurrentExperimentId,
 } from './platformContextHelpers'
+import {
+  hasKeys,
+  pluginEndpointRequestParts,
+  requestBodyFromPayload,
+} from './pluginEndpointBuilder'
 import type { ExperimentSummary, PageSelectorItem } from '../types'
 
+export {
+  buildPluginEndpointUrl,
+  resolvePluginBaseUrl,
+} from './pluginEndpointBuilder'
+
 export type PluginHttpMethod = 'get' | 'post' | 'put' | 'patch' | 'delete'
 
 export interface PluginEndpointContract {
@@ -115,19 +125,6 @@ export interface UseCurrentExperimentReturn<TExperiment = ExperimentSummary> {
 export type PluginEndpointCaller = (payload?: unknown) => Promise<unknown>
 export type GeneratedPluginClient = Record<string, (...args: any[]) => Promise<any>>
 
-function normalizeApiBaseUrl(baseUrl: string | undefined): string | undefined {
-  if (!baseUrl) return undefined
-  return baseUrl.length > 1 ? baseUrl.replace(/\/+$/, '') : baseUrl
-}
-
-function normalizeApiPrefix(prefix: string | undefined): string | undefined {
-  if (!prefix) return undefined
-  if (prefix.startsWith('/api/')) return normalizeApiBaseUrl(prefix)
-  if (prefix === '/api') return prefix
-  if (prefix.startsWith('/')) return normalizeApiBaseUrl(`/api${prefix}`)
-  return normalizeApiBaseUrl(`/api/${prefix}`)
-}
-
 function normalizePluginNavPath(path: string): string {
   const raw = path.trim() || '/'
   const prefixed = raw.startsWith('/') ? raw : `/${raw}`
@@ -163,186 +160,6 @@ export function getPluginPageSelectorItems(contract: PluginContract): PageSelect
   }))
 }
 
-/** Resolve the runtime plugin API base URL from env, explicit options, platform injection, or contract metadata. */
-export function resolvePluginBaseUrl(contract: PluginContract, explicitBaseUrl?: string): string {
-  const envPrefix = (import.meta.env?.VITE_API_PREFIX as string | undefined) || undefined
-  if (envPrefix) return normalizeApiBaseUrl(envPrefix) ?? envPrefix
-  if (explicitBaseUrl) return normalizeApiBaseUrl(explicitBaseUrl) ?? explicitBaseUrl
-
-  const injected = getInjectedPlatformContext()
-  const platformPrefix =
-    normalizeApiBaseUrl(injected?.plugin?.api_prefix) ||
-    normalizeApiPrefix(injected?.plugin?.route_prefix)
-  if (platformPrefix) return platformPrefix
-
-  return normalizeApiBaseUrl(contract.plugin.apiPrefix) || '/api'
-}
-
-function encodePath(path: string, payload: Record<string, unknown>, pathParams: string[]): string {
-  let nextPath = path
-  for (const param of pathParams) {
-    const value = payload[param]
-    if (value === undefined || value === null) {
-      throw new Error(`[MINT SDK] Missing path parameter '${param}' for plugin endpoint ${path}`)
-    }
-    nextPath = nextPath.replace(`{${param}}`, encodeURIComponent(String(value)))
-    nextPath = nextPath.replace(`:${param}`, encodeURIComponent(String(value)))
-  }
-  return nextPath
-}
-
-function withDefaultPathParams(
-  payload: Record<string, unknown>,
-  pathParams: string[],
-): Record<string, unknown> {
-  if (!pathParams.length) return payload
-  const nextPayload = { ...payload }
-  for (const param of pathParams) {
-    if (nextPayload[param] !== undefined && nextPayload[param] !== null) continue
-    if (isExperimentPathParam(param)) {
-      const experimentId = resolveCurrentExperimentId()
-      if (experimentId !== undefined) {
-        nextPayload[param] = experimentId
-      }
-    }
-  }
-  return nextPayload
-}
-
-function isExperimentPathParam(param: string): boolean {
-  return param === 'experimentId' || param === 'experiment_id'
-}
-
-function withoutPathParams(payload: Record<string, unknown>, pathParams: string[]) {
-  const copy = { ...payload }
-  for (const param of pathParams) {
-    delete copy[param]
-  }
-  return copy
-}
-
-function queryParamsFromPayload(
-  payload: Record<string, unknown>,
-  pathParams: string[],
-  queryParams?: PluginEndpointParamDefinition[],
-  endpointPath?: string,
-  includeUnspecifiedParams = false,
-) {
-  if (!queryParams?.length) {
-    return includeUnspecifiedParams ? withoutPathParams(payload, pathParams) : {}
-  }
-
-  const query: Record<string, unknown> = {}
-  for (const param of queryParams) {
-    const name = typeof param === 'string' ? param : param.name
-    const fieldName = typeof param === 'string' ? param : param.fieldName ?? param.name
-    const required = typeof param !== 'string' && param.required === true
-    const value = payload[fieldName]
-    if (value === undefined || value === null) {
-      if (required) {
-        throw new Error(
-          `[MINT SDK] Missing query parameter '${fieldName}' for plugin endpoint ${endpointPath ?? ''}`,
-        )
-      }
-      continue
-    }
-    query[name] = value
-  }
-  return query
-}
-
-function hasKeys(value: Record<string, unknown>): boolean {
-  return Object.keys(value).length > 0
-}
-
-function requestBodyFromPayload(
-  payload: unknown,
-  requestPayload: Record<string, unknown>,
-  endpoint: PluginEndpointDefinition,
-): unknown {
-  if (!endpoint.hasBody) return undefined
-  const body = endpoint.pathParams?.length || endpoint.queryParams?.length
-    ? requestPayload.body
-    : payload
-  if (body === undefined || body === null) {
-    throw new Error(`[MINT SDK] Missing request body for plugin endpoint ${endpoint.path}`)
-  }
-  return body
-}
-
-function pluginEndpointRequestParts(
-  contract: PluginContract,
-  endpoint: PluginEndpointDefinition,
-  payload?: unknown,
-  explicitBaseUrl?: string,
-) {
-  const payloadObject =
-    payload && typeof payload === 'object' && !Array.isArray(payload)
-      ? payload as Record<string, unknown>
-      : {}
-  const pathParams = endpoint.pathParams ?? []
-  const requestPayload = withDefaultPathParams(payloadObject, pathParams)
-  const path = encodePath(endpoint.path, requestPayload, pathParams)
-  const query = queryParamsFromPayload(
-    requestPayload,
-    pathParams,
-    endpoint.queryParams,
-    endpoint.path,
-    endpoint.method === 'get',
-  )
-
-  return {
-    baseUrl: resolvePluginBaseUrl(contract, explicitBaseUrl),
-    path,
-    query,
-    requestPayload,
-  }
-}
-
-function appendQueryValue(params: URLSearchParams, key: string, value: unknown): void {
-  if (value === undefined || value === null) return
-  if (Array.isArray(value)) {
-    for (const item of value) {
-      appendQueryValue(params, key, item)
-    }
-    return
-  }
-  if (typeof value === 'object') {
-    params.append(key, JSON.stringify(value))
-    return
-  }
-  params.append(key, String(value))
-}
-
-function queryString(query: Record<string, unknown>): string {
-  const params = new URLSearchParams()
-  for (const [key, value] of Object.entries(query)) {
-    appendQueryValue(params, key, value)
-  }
-  const serialized = params.toString()
-  return serialized ? `?${serialized}` : ''
-}
-
-function joinBaseUrl(baseUrl: string, path: string): string {
-  if (!baseUrl) return path
-  const normalizedBase = baseUrl.endsWith('/') ? baseUrl.slice(0, -1) : baseUrl
-  const normalizedPath = path.startsWith('/') ? path : `/${path}`
-  return `${normalizedBase}${normalizedPath}`
-}
-
-/** Build the concrete URL for a generated plugin endpoint without making a request. */
-export function buildPluginEndpointUrl(
-  contract: PluginContract,
-  endpoint: PluginEndpointDefinition,
-  payload?: unknown,
-  options: BuildPluginEndpointUrlOptions = {},
-): string {
-  const parts = pluginEndpointRequestParts(contract, endpoint, payload, options.baseUrl)
-  const pathWithQuery = `${parts.path}${queryString(parts.query)}`
-  if (options.includeBaseUrl === false) return pathWithQuery
-  return joinBaseUrl(parts.baseUrl, pathWithQuery)
-}
-
 /** Create a typed plugin API client from a generated MINT plugin contract. */
 export function createPluginClient<TClient extends object = GeneratedPluginClient>(
   contract: PluginContract,