@open-mercato/shared 0.4.2-canary-c02407ff85

package/src/lib/openapi/index.ts

@@ -0,0 +1,4 @@
+export * from './types'
+export { buildOpenApiDocument, generateMarkdownFromOpenApi } from './generator'
+export * from './crud'
+export { sanitizeOpenApiDocument } from './sanitize'

package/src/lib/openapi/sanitize.ts

@@ -0,0 +1,137 @@
+type JsonValue = string | number | boolean | null | JsonValue[] | { [key: string]: JsonValue }
+type MutableOpenApiDoc = Record<string, any> & {
+  components?: {
+    schemas?: Record<string, JsonValue>
+  }
+}
+
+function isPlainObject(value: unknown): value is Record<string, any> {
+  return typeof value === 'object' && value !== null && Object.getPrototypeOf(value) === Object.prototype
+}
+
+function toComponentName(hint: string, fallbackIndex: number): string {
+  const cleaned = hint
+    .split(/[^a-zA-Z0-9]+/)
+    .filter(Boolean)
+    .map((segment) => segment.charAt(0).toUpperCase() + segment.slice(1))
+    .join('')
+  return cleaned.length ? cleaned : `Schema${fallbackIndex}`
+}
+
+const SCHEMA_KEYS = new Set([
+  'type',
+  'properties',
+  'items',
+  'anyOf',
+  'oneOf',
+  'allOf',
+  '$ref',
+  'enum',
+  'format',
+  'not',
+  'additionalProperties',
+  'required',
+  'pattern',
+  'minimum',
+  'maximum',
+])
+
+function looksLikeSchema(value: Record<string, unknown>): boolean {
+  if (typeof value.$ref === 'string') return true
+  for (const key of Object.keys(value)) {
+    if (SCHEMA_KEYS.has(key)) return true
+  }
+  return false
+}
+
+export function sanitizeOpenApiDocument<T extends Record<string, any>>(doc: T): T {
+  const target = doc as T & MutableOpenApiDoc
+  const schemaNameMap = new Map<object, string>()
+  const schemas: Record<string, JsonValue> = target.components?.schemas ?? {}
+  if (!target.components) target.components = {}
+  target.components.schemas = schemas
+  let counter = Object.keys(schemas).length
+
+  const cloneContainer = (
+    source: Record<string, any>,
+    hint: string,
+    mode?: 'properties' | 'patternProperties'
+  ): JsonValue => {
+    const clone: Record<string, JsonValue> = {}
+    for (const [key, value] of Object.entries(source)) {
+      const forceSchema = mode === 'properties' || mode === 'patternProperties'
+      clone[key] = cloneSchemaValue(value, `${hint}_${key}`, key, forceSchema)
+    }
+    return clone
+  }
+
+  const serializeSchema = (schema: Record<string, any>, hint: string): JsonValue => {
+    if (schemaNameMap.has(schema)) {
+      const name = schemaNameMap.get(schema)!
+      return { $ref: `#/components/schemas/${name}` }
+    }
+    counter += 1
+    const tentativeName = toComponentName(hint, counter)
+    let name = tentativeName
+    let suffix = 1
+    while (schemas[name]) {
+      name = `${tentativeName}${suffix++}`
+    }
+    schemaNameMap.set(schema, name)
+    schemas[name] = cloneContainer(schema, hint)
+    return { $ref: `#/components/schemas/${name}` }
+  }
+
+  const cloneSchemaValue = (
+    value: any,
+    hint: string,
+    parentKey?: string,
+    forceSchema = false
+  ): JsonValue => {
+    if (Array.isArray(value)) {
+      return value.map((entry, idx) => cloneSchemaValue(entry, `${hint}_${idx}`, parentKey, forceSchema)) as JsonValue
+    }
+    if (isPlainObject(value)) {
+      if (typeof value.$ref === 'string') return value
+      if (parentKey === 'properties' || parentKey === 'patternProperties') {
+        return cloneContainer(value, hint, parentKey)
+      }
+      if (parentKey === 'additionalProperties' && Object.keys(value).length) {
+        return serializeSchema(value, hint)
+      }
+      if (forceSchema || looksLikeSchema(value)) {
+        return serializeSchema(value, hint)
+      }
+      return cloneContainer(value, hint)
+    }
+    // Convert BigInt to string for JSON serialization
+    if (typeof value === 'bigint') {
+      return value.toString()
+    }
+    return value as JsonValue
+  }
+
+  const traverse = (value: any, hint: string): any => {
+    if (Array.isArray(value)) {
+      return value.map((entry, idx) => traverse(entry, `${hint}_${idx}`))
+    }
+    if (!isPlainObject(value)) {
+      // Convert BigInt to string for JSON serialization
+      if (typeof value === 'bigint') {
+        return value.toString()
+      }
+      return value
+    }
+    const result: Record<string, unknown> = { ...value }
+    for (const [key, child] of Object.entries(result)) {
+      if (key === 'schema' && child && typeof child === 'object') {
+        result[key] = cloneSchemaValue(child, `${hint}_${key}`, key)
+      } else {
+        result[key] = traverse(child, `${hint}_${key}`)
+      }
+    }
+    return result
+  }
+
+  return traverse(target, 'doc') as T
+}

package/src/lib/openapi/types.ts

@@ -0,0 +1,79 @@
+import type { ZodTypeAny } from 'zod'
+
+export type OpenApiHttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE'
+
+export type OpenApiSecurityScheme = 'bearerAuth'
+
+export type OpenApiCodeSample = {
+  lang: string
+  label?: string
+  source: string
+}
+
+export type OpenApiResponseDoc = {
+  status: number
+  description?: string
+  schema?: ZodTypeAny
+  example?: unknown
+  mediaType?: string
+  xAutoGenerated?: boolean
+}
+
+export type OpenApiRequestBodyDoc = {
+  contentType?: string
+  schema: ZodTypeAny
+  example?: unknown
+  description?: string
+}
+
+export type OpenApiMethodDoc = {
+  operationId?: string
+  summary?: string
+  description?: string
+  tags?: string[]
+  query?: ZodTypeAny
+  headers?: ZodTypeAny
+  pathParams?: ZodTypeAny
+  requestBody?: OpenApiRequestBodyDoc
+  responses?: OpenApiResponseDoc[]
+  errors?: OpenApiResponseDoc[]
+  deprecated?: boolean
+  security?: OpenApiSecurityScheme[]
+  codeSamples?: OpenApiCodeSample[]
+  externalDocs?: { url: string; description?: string }
+  extensions?: Record<string, unknown>
+}
+
+export type OpenApiRouteDoc = {
+  tag?: string
+  summary?: string
+  description?: string
+  pathParams?: ZodTypeAny
+  methods: Partial<Record<OpenApiHttpMethod, OpenApiMethodDoc>>
+  extensions?: Record<string, unknown>
+}
+
+export type OpenApiDocumentOptions = {
+  title?: string
+  version?: string
+  description?: string
+  servers?: Array<{ url: string; description?: string }>
+  baseUrlForExamples?: string
+  defaultSecurity?: OpenApiSecurityScheme[]
+}
+
+export type OpenApiDocument = {
+  openapi: '3.1.0'
+  info: {
+    title: string
+    version: string
+    description?: string
+  }
+  servers?: Array<{ url: string; description?: string }>
+  tags?: Array<{ name: string; description?: string }>
+  paths: Record<string, Record<string, any>>
+  components?: {
+    schemas?: Record<string, any>
+    securitySchemes?: Record<string, any>
+  }
+}

package/src/lib/profiler/index.ts

@@ -0,0 +1,371 @@
+import { parseBooleanToken } from '../boolean'
+
+const ROUND_PRECISION = 1000
+const NS_PER_MS = BigInt(1_000_000)
+const BIGINT_ZERO = BigInt(0)
+
+export type ProfilerExtra = Record<string, unknown>
+
+export type ProfilerSnapshotNode = {
+  label: string
+  durationMs: number
+  extra?: ProfilerExtra
+  children?: ProfilerSnapshotNode[]
+  type?: 'mark' | 'span' | 'record'
+}
+
+export type ProfilerSnapshot = {
+  scope: string
+  target?: string
+  totalMs: number
+  tree: ProfilerSnapshotNode[]
+  meta?: ProfilerExtra
+}
+
+export type ProfilerSection = {
+  end: (extra?: ProfilerExtra) => void
+}
+
+export type Profiler = {
+  readonly enabled: boolean
+  mark: (label: string, extra?: ProfilerExtra) => void
+  section: (label: string, extra?: ProfilerExtra) => ProfilerSection
+  measure: <T>(
+    label: string,
+    fn: () => Promise<T> | T,
+    extra?: ((result: T) => ProfilerExtra | undefined) | ProfilerExtra
+  ) => Promise<T>
+  record: (label: string, durationMs: number, extra?: ProfilerExtra) => void
+  child: (label: string, extra?: ProfilerExtra) => Profiler
+  end: (extra?: ProfilerExtra) => void
+}
+
+type ProfilerNodeCommon = {
+  label: string
+  start: bigint
+  durationNs: bigint
+  extra?: ProfilerExtra
+  type: 'mark' | 'span' | 'record'
+}
+
+type ProfilerSpanNode = ProfilerNodeCommon & {
+  type: 'span'
+  children: ProfilerInternalNode[]
+  lastTimestamp: bigint
+  closed: boolean
+}
+
+type ProfilerMarkNode = ProfilerNodeCommon & { type: 'mark' }
+type ProfilerRecordNode = ProfilerNodeCommon & { type: 'record' }
+
+type ProfilerInternalNode = ProfilerSpanNode | ProfilerMarkNode | ProfilerRecordNode
+
+type ProfilerRootState = {
+  scope: string
+  target?: string
+  label: string
+  loggerLabel: string
+  enabled: boolean
+  startedAt: bigint
+  lastTimestamp: bigint
+  nodes: ProfilerInternalNode[]
+  closed: boolean
+  meta?: ProfilerExtra
+}
+
+type ProfilerImplOptions = {
+  root: ProfilerRootState
+  span?: ProfilerSpanNode
+  parent?: ProfilerImpl
+}
+
+function now(): bigint {
+  return process.hrtime.bigint()
+}
+
+function roundDuration(ns: bigint): number {
+  if (ns <= BIGINT_ZERO) return 0
+  const ms = Number(ns) / Number(NS_PER_MS)
+  return Math.round(ms * ROUND_PRECISION) / ROUND_PRECISION
+}
+
+function mergeExtra(base: ProfilerExtra | undefined, extra: ProfilerExtra | undefined): ProfilerExtra | undefined {
+  if (!base && !extra) return undefined
+  if (!base) return extra ? { ...extra } : undefined
+  if (!extra) return base ? { ...base } : undefined
+  return { ...base, ...extra }
+}
+
+function serializeNode(node: ProfilerInternalNode): ProfilerSnapshotNode {
+  const base: ProfilerSnapshotNode = {
+    label: node.label,
+    durationMs: roundDuration(node.durationNs),
+  }
+  if (node.extra && Object.keys(node.extra).length > 0) {
+    base.extra = node.extra
+  }
+  base.type = node.type
+  if (node.type === 'span' && node.children.length > 0) {
+    base.children = node.children.map(serializeNode)
+  }
+  return base
+}
+
+class ProfilerImpl implements Profiler {
+  private span?: ProfilerSpanNode
+  private parent?: ProfilerImpl
+  private root: ProfilerRootState
+  private lastTimestamp: bigint
+  private closed = false
+
+  constructor(options: ProfilerImplOptions) {
+    this.root = options.root
+    this.span = options.span
+    this.parent = options.parent
+    this.lastTimestamp = options.span ? options.span.lastTimestamp : options.root.lastTimestamp
+  }
+
+  get enabled(): boolean {
+    return this.root.enabled
+  }
+
+  mark(label: string, extra?: ProfilerExtra) {
+    if (!this.enabled || this.closed) return
+    const timestamp = now()
+    const duration = timestamp - this.lastTimestamp
+    const node: ProfilerMarkNode = {
+      type: 'mark',
+      label,
+      start: timestamp,
+      durationNs: duration >= BIGINT_ZERO ? duration : BIGINT_ZERO,
+      extra: extra ? { ...extra } : undefined,
+    }
+    this.appendNode(node)
+    this.updateTimestamps(timestamp)
+  }
+
+  section(label: string, extra?: ProfilerExtra): ProfilerSection {
+    if (!this.enabled || this.closed) {
+      return disabledSection
+    }
+    const child = this.child(label, extra)
+    return {
+      end: (childExtra?: ProfilerExtra) => child.end(childExtra),
+    }
+  }
+
+  async measure<T>(
+    label: string,
+    fn: () => Promise<T> | T,
+    extra?: ((result: T) => ProfilerExtra | undefined) | ProfilerExtra
+  ): Promise<T> {
+    if (!this.enabled || this.closed) {
+      return Promise.resolve(fn())
+    }
+    const child = this.child(label)
+    try {
+      const result = await Promise.resolve(fn())
+      const payload = typeof extra === 'function' ? extra(result) : extra
+      child.end(payload)
+      return result
+    } catch (err) {
+      child.end({ error: err instanceof Error ? err.message : String(err) })
+      throw err
+    }
+  }
+
+  record(label: string, durationMs: number, extra?: ProfilerExtra) {
+    if (!this.enabled || this.closed) return
+    const safeDurationMs = Number.isFinite(durationMs) && durationMs > 0 ? durationMs : 0
+    const durationNs = BigInt(Math.round(safeDurationMs * Number(NS_PER_MS)))
+    const node: ProfilerRecordNode = {
+      type: 'record',
+      label,
+      start: this.lastTimestamp,
+      durationNs: durationNs >= BIGINT_ZERO ? durationNs : BIGINT_ZERO,
+      extra: extra ? { ...extra } : undefined,
+    }
+    this.appendNode(node)
+    this.updateTimestamps(this.lastTimestamp + node.durationNs)
+  }
+
+  child(label: string, extra?: ProfilerExtra): Profiler {
+    if (!this.enabled || this.closed) return disabledProfiler
+    const timestamp = now()
+    const span: ProfilerSpanNode = {
+      type: 'span',
+      label,
+      start: timestamp,
+      durationNs: BIGINT_ZERO,
+      extra: extra ? { ...extra } : undefined,
+      children: [],
+      lastTimestamp: timestamp,
+      closed: false,
+    }
+    this.appendNode(span)
+    this.updateTimestamps(timestamp)
+    return new ProfilerImpl({ root: this.root, span, parent: this })
+  }
+
+  end(extra?: ProfilerExtra) {
+    if (!this.enabled || this.closed) return
+    const current = now()
+    if (this.span) {
+      this.closeSpan(current, extra)
+    } else {
+      this.closeRoot(current, extra)
+    }
+  }
+
+  private appendNode(node: ProfilerInternalNode) {
+    if (this.span) {
+      this.span.children.push(node)
+      this.span.lastTimestamp = node.start
+    } else {
+      this.root.nodes.push(node)
+    }
+  }
+
+  private updateTimestamps(newTimestamp: bigint) {
+    if (this.span) {
+      this.span.lastTimestamp = newTimestamp
+    } else {
+      this.root.lastTimestamp = newTimestamp
+    }
+    this.lastTimestamp = newTimestamp
+  }
+
+  private closeSpan(closedAt: bigint, extra?: ProfilerExtra) {
+    if (!this.span || this.span.closed) return
+    const effectiveEnd = closedAt >= this.span.start ? closedAt : this.span.start
+    this.span.durationNs = effectiveEnd - this.span.start
+    this.span.extra = mergeExtra(this.span.extra, extra)
+    this.span.closed = true
+    this.closed = true
+    this.updateTimestamps(effectiveEnd)
+    if (this.parent) {
+      this.parent.updateTimestamps(effectiveEnd)
+    } else {
+      this.root.lastTimestamp = effectiveEnd
+    }
+  }
+
+  private closeRoot(closedAt: bigint, extra?: ProfilerExtra) {
+    if (this.root.closed) return
+    const endTime = closedAt >= this.root.startedAt ? closedAt : this.root.startedAt
+    this.root.lastTimestamp = endTime
+    this.root.meta = mergeExtra(this.root.meta, extra)
+    this.root.closed = true
+    this.closed = true
+    const totalNs = endTime - this.root.startedAt
+    const snapshot: ProfilerSnapshot = {
+      scope: this.root.scope,
+      target: this.root.target,
+      totalMs: roundDuration(totalNs),
+      tree: this.root.nodes.map(serializeNode),
+    }
+    if (this.root.meta && Object.keys(this.root.meta).length > 0) {
+      snapshot.meta = this.root.meta
+    }
+    const serialized = JSON.stringify(snapshot, null, 2)
+    try {
+      console.info(this.root.loggerLabel, serialized)
+    } catch {
+      // ignore logging failures
+    }
+  }
+}
+
+const disabledSection: ProfilerSection = { end: () => {} }
+
+const disabledProfiler: Profiler = {
+  get enabled() {
+    return false
+  },
+  mark: () => {},
+  section: () => disabledSection,
+  measure: async (_label, fn) => Promise.resolve(fn()),
+  record: () => {},
+  child: () => disabledProfiler,
+  end: () => {},
+}
+
+export type CreateProfilerOptions = {
+  scope: string
+  target?: string
+  label?: string
+  enabled?: boolean
+  loggerLabel?: string
+  meta?: ProfilerExtra
+}
+
+export function createProfiler(options: CreateProfilerOptions): Profiler {
+  if (options.enabled === false) return disabledProfiler
+  const startedAt = now()
+  const enabledFlag = options.enabled !== undefined ? options.enabled : true
+  const root: ProfilerRootState = {
+    scope: options.scope,
+    target: options.target,
+    label: options.label ?? options.scope,
+    loggerLabel: options.loggerLabel ?? '[profile]',
+    enabled: enabledFlag,
+    startedAt,
+    lastTimestamp: startedAt,
+    nodes: [],
+    closed: false,
+    meta: options.meta ? { ...options.meta } : undefined,
+  }
+  return new ProfilerImpl({ root })
+}
+
+export function normalizeProfilerTokens(input: string | null | undefined): string[] {
+  if (!input) return []
+  return input
+    .split(',')
+    .map((token) => token.trim().toLowerCase())
+    .filter((token) => token.length > 0)
+}
+
+export function profilerMatches(target: string, tokens: string[]): boolean {
+  if (!tokens.length) return false
+  const lower = target.toLowerCase()
+  return tokens.some((token) => {
+    if (token === '*' || token === 'all' || parseBooleanToken(token) === true) return true
+    if (token.endsWith('*')) {
+      const prefix = token.slice(0, -1)
+      return prefix.length === 0 ? true : lower.startsWith(prefix)
+    }
+    return token === lower
+  })
+}
+
+const DEFAULT_ENV_KEYS = [
+  'OM_PROFILE',
+  'NEXT_PUBLIC_OM_PROFILE',
+  'OM_CRUD_PROFILE',
+  'NEXT_PUBLIC_OM_CRUD_PROFILE',
+  'OM_QE_PROFILE',
+  'NEXT_PUBLIC_OM_QE_PROFILE',
+] as const
+
+export function resolveProfilerTokens(envKeys: readonly string[] = DEFAULT_ENV_KEYS): string[] {
+  const tokens: string[] = []
+  envKeys.forEach((key) => {
+    const raw = process.env[key]
+    if (!raw) return
+    const parsed = normalizeProfilerTokens(raw)
+    if (parsed.length) tokens.push(...parsed)
+  })
+  return Array.from(new Set(tokens))
+}
+
+export function shouldEnableProfiler(
+  target: string,
+  options?: { tokens?: string[]; envKeys?: readonly string[] }
+): boolean {
+  const tokens = options?.tokens ?? resolveProfilerTokens(options?.envKeys)
+  if (!tokens.length) return false
+  return profilerMatches(target, tokens)
+}
+
+export const disabledProfilerInstance = disabledProfiler