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

package/src/composables/controlSchemaUtils.ts

@@ -0,0 +1,36 @@
+export function recordValue(value: unknown): Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value)
+    ? value as Record<string, unknown>
+    : {}
+}
+
+export function numericValue(value: number | { value: number; message: string }): number {
+  return typeof value === 'number' ? value : value.value
+}
+
+export function orderedUnique(values: string[]): string[] {
+  return [...new Set(values)]
+}
+
+export function replaceRecord(target: Record<string, unknown>, values: Record<string, unknown>) {
+  for (const key of Object.keys(target)) {
+    delete target[key]
+  }
+  Object.assign(target, values)
+}
+
+export function omitUndefined<T extends object>(record: T): T {
+  const next: Record<string, unknown> = {}
+  for (const [key, value] of Object.entries(record as Record<string, unknown>)) {
+    if (value !== undefined) next[key] = value
+  }
+  return next as T
+}
+
+export function humanize(value: string): string {
+  return value
+    .replace(/[_-]+/g, ' ')
+    .replace(/([a-z])([A-Z])/g, '$1 $2')
+    .trim()
+    .replace(/\w\S*/g, word => word.charAt(0).toUpperCase() + word.slice(1))
+}

package/src/composables/controlWorkspaceOptions.ts

@@ -0,0 +1,21 @@
+import type {
+  ControlWorkspaceOptions,
+} from './controlSchemaTypes'
+
+export function mergeControlWorkspaceOptions(
+  base?: ControlWorkspaceOptions,
+  override?: ControlWorkspaceOptions,
+): ControlWorkspaceOptions {
+  return {
+    ...(base ?? {}),
+    ...(override ?? {}),
+    initialValues: {
+      ...(base?.initialValues ?? {}),
+      ...(override?.initialValues ?? {}),
+    },
+    topBarSettings: {
+      ...(base?.topBarSettings ?? {}),
+      ...(override?.topBarSettings ?? {}),
+    },
+  }
+}

package/src/composables/formBuilderSchema.ts

@@ -0,0 +1,153 @@
+import { getTypeDefault } from './formBuilderRegistry'
+import type { FieldRules } from './useForm'
+import type {
+  FieldCondition,
+  FieldValidation,
+  FormEnhancements,
+  FormFieldSchema,
+  FormSchema,
+  FormSectionSchema,
+} from '../types/form-builder'
+
+/**
+ * Evaluate a JSON-serializable field condition against the current form data.
+ *
+ * Supports logical operators (`and`, `or`, `not`) and comparison operators
+ * (`eq`, `neq`, `gt`, `lt`, `gte`, `lte`, `in`, `notIn`, `truthy`, `falsy`,
+ * `contains`). Returns `true` if the condition passes.
+ */
+export function evaluateCondition(
+  condition: FieldCondition,
+  data: Record<string, unknown>,
+): boolean {
+  if ('and' in condition) {
+    return condition.and.every((c) => evaluateCondition(c, data))
+  }
+  if ('or' in condition) {
+    return condition.or.some((c) => evaluateCondition(c, data))
+  }
+  if ('not' in condition) {
+    return !evaluateCondition(condition.not, data)
+  }
+
+  const value = data[condition.field]
+
+  if ('eq' in condition) return value === condition.eq
+  if ('neq' in condition) return value !== condition.neq
+  if ('gt' in condition) return typeof value === 'number' && value > condition.gt
+  if ('lt' in condition) return typeof value === 'number' && value < condition.lt
+  if ('gte' in condition) return typeof value === 'number' && value >= condition.gte
+  if ('lte' in condition) return typeof value === 'number' && value <= condition.lte
+  if ('in' in condition) return condition.in.includes(value)
+  if ('notIn' in condition) return !condition.notIn.includes(value)
+  if ('truthy' in condition) return !!value
+  if ('falsy' in condition) return !value
+  if ('contains' in condition) {
+    if (typeof value === 'string') return value.includes(condition.contains)
+    if (Array.isArray(value)) return value.includes(condition.contains)
+    return false
+  }
+
+  return true
+}
+
+/** Return all sections across steps (wizard) or directly from a flat schema. */
+export function collectSections(schema: FormSchema): FormSectionSchema[] {
+  return schema.steps ? schema.steps.flatMap((step) => step.sections) : schema.sections
+}
+
+/** Return all field schemas in schema order, flattening sections and steps. */
+export function flattenFields(schema: FormSchema): FormFieldSchema[] {
+  return collectSections(schema).flatMap((section) => section.fields)
+}
+
+/** Convert a JSON-safe `FieldValidation` descriptor to a runtime `FieldRules` object. */
+function convertValidation(v: FieldValidation): FieldRules {
+  const rules: FieldRules = {}
+
+  if (v.required !== undefined) rules.required = v.required
+  if (v.minLength !== undefined) rules.minLength = v.minLength
+  if (v.maxLength !== undefined) rules.maxLength = v.maxLength
+  if (v.min !== undefined) rules.min = v.min
+  if (v.max !== undefined) rules.max = v.max
+  if (v.email !== undefined) rules.email = v.email
+
+  if (v.pattern !== undefined) {
+    rules.pattern =
+      typeof v.pattern === 'string'
+        ? new RegExp(v.pattern)
+        : { value: new RegExp(v.pattern.value), message: v.pattern.message }
+  }
+
+  return rules
+}
+
+export function buildInitialValues<T extends Record<string, unknown>>(
+  fields: readonly FormFieldSchema[],
+  initialData?: Partial<T>,
+): Record<string, unknown> {
+  const initialValues = {} as Record<string, unknown>
+
+  for (const field of fields) {
+    const key = field.name
+    if (initialData && hasOwnKey(initialData, key)) {
+      initialValues[key] = (initialData as Record<string, unknown>)[key]
+    } else if (field.defaultValue !== undefined) {
+      initialValues[key] = field.defaultValue
+    } else {
+      initialValues[key] = getTypeDefault(field.type)
+    }
+  }
+
+  return initialValues
+}
+
+export function buildRules<T extends Record<string, unknown>>(
+  fields: readonly FormFieldSchema[],
+  enhancements?: FormEnhancements<T>,
+): Partial<Record<string, FieldRules>> {
+  const rules: Partial<Record<string, FieldRules>> = {}
+
+  for (const field of fields) {
+    const base: FieldRules = field.validation ? convertValidation(field.validation) : {}
+    const enhancement = enhancements?.fields?.[field.name as keyof T]
+
+    const customValidators: Array<(
+      value: unknown,
+      formData: Record<string, unknown>,
+    ) => string | undefined | null> = []
+
+    if (enhancement?.validate) {
+      const fn = enhancement.validate
+      customValidators.push((value, formData) => fn(value, formData as T))
+    }
+
+    if (customValidators.length > 0) {
+      base.custom = customValidators
+    }
+
+    if (Object.keys(base).length > 0) {
+      rules[field.name] = base
+    }
+  }
+
+  return rules
+}
+
+export function replaceArray<T>(target: T[], values: readonly T[]): void {
+  target.splice(0, target.length, ...values)
+}
+
+export function replaceRecord<TValue>(
+  target: Partial<Record<string, TValue>>,
+  source: Partial<Record<string, TValue>>,
+): void {
+  for (const key of Object.keys(target)) {
+    delete target[key]
+  }
+  Object.assign(target, source)
+}
+
+function hasOwnKey(source: object, key: string): boolean {
+  return Object.prototype.hasOwnProperty.call(source, key)
+}

package/src/composables/pluginEndpointBuilder.ts

@@ -0,0 +1,203 @@
+import {
+  getInjectedPlatformContext,
+  resolveCurrentExperimentId,
+} from './platformContextHelpers'
+import type {
+  BuildPluginEndpointUrlOptions,
+  PluginContract,
+  PluginEndpointDefinition,
+  PluginEndpointParamDefinition,
+} from './usePluginClient'
+
+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}`)
+}
+
+/** 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
+}
+
+export function hasKeys(value: Record<string, unknown>): boolean {
+  return Object.keys(value).length > 0
+}
+
+export 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
+}
+
+export 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)
+}