@open-mercato/shared 0.4.2-canary-c02407ff85

package/src/modules/__tests__/dsl.test.ts

@@ -0,0 +1,35 @@
+import { defineLink, entityId, linkable, defineFields, cf } from '../../modules/dsl'
+
+describe('DSL helpers', () => {
+  test('defineLink + entityId', () => {
+    const link = defineLink(entityId('auth','user'), entityId('my_module','user_profile'), {
+      join: { baseKey: 'id', extensionKey: 'user_id' },
+      cardinality: 'one-to-one',
+      required: false,
+      description: 'Profile for user',
+    })
+    expect(link.base).toBe('auth:user')
+    expect(link.extension).toBe('my_module:user_profile')
+    expect(link.join).toEqual({ baseKey: 'id', extensionKey: 'user_id' })
+  })
+
+  test('linkable helper', () => {
+    const Auth = { linkable: linkable('auth', ['user','role']) }
+    expect(Auth.linkable.user).toBe('auth:user')
+    expect(Auth.linkable.role).toBe('auth:role')
+  })
+
+  test('defineFields + cf helpers', () => {
+    const set = defineFields(entityId('directory','organization'), [
+      cf.select('industry', ['SaaS','Retail'], { filterable: true }),
+      cf.boolean('vip', { required: false }),
+      cf.integer('priority'),
+    ], 'my_module')
+    expect(set.entity).toBe('directory:organization')
+    expect(set.fields[0]).toMatchObject({ key: 'industry', kind: 'select', options: ['SaaS','Retail'], filterable: true })
+    expect(set.fields[1]).toMatchObject({ key: 'vip', kind: 'boolean' })
+    expect(set.fields[2]).toMatchObject({ key: 'priority', kind: 'integer' })
+    expect(set.source).toBe('my_module')
+  })
+})
+

package/src/modules/__tests__/registry.test.ts

@@ -0,0 +1,300 @@
+import type { Module } from '../registry'
+import {
+  registerCliModules,
+  getCliModules,
+  hasCliModules,
+  findFrontendMatch,
+  findBackendMatch,
+  findApi,
+} from '../registry'
+
+describe('CLI Modules Registry', () => {
+  // Clear the registry before each test
+  beforeEach(() => {
+    registerCliModules([])
+  })
+
+  afterEach(() => {
+    registerCliModules([])
+  })
+
+  describe('registerCliModules', () => {
+    it('should register modules', () => {
+      const modules: Module[] = [
+        { id: 'module-a' },
+        { id: 'module-b' },
+      ]
+
+      registerCliModules(modules)
+
+      expect(getCliModules()).toEqual(modules)
+    })
+
+    it('should overwrite previously registered modules', () => {
+      const modules1: Module[] = [{ id: 'module-a' }]
+      const modules2: Module[] = [{ id: 'module-b' }, { id: 'module-c' }]
+
+      registerCliModules(modules1)
+      expect(getCliModules().length).toBe(1)
+
+      registerCliModules(modules2)
+      expect(getCliModules().length).toBe(2)
+      expect(getCliModules().map(m => m.id)).toEqual(['module-b', 'module-c'])
+    })
+  })
+
+  describe('getCliModules', () => {
+    it('should return empty array when no modules registered', () => {
+      expect(getCliModules()).toEqual([])
+    })
+
+    it('should return registered modules', () => {
+      const modules: Module[] = [
+        { id: 'test-module', info: { name: 'Test Module' } },
+      ]
+
+      registerCliModules(modules)
+
+      const result = getCliModules()
+      expect(result.length).toBe(1)
+      expect(result[0].id).toBe('test-module')
+      expect(result[0].info?.name).toBe('Test Module')
+    })
+  })
+
+  describe('hasCliModules', () => {
+    it('should return false when no modules registered', () => {
+      expect(hasCliModules()).toBe(false)
+    })
+
+    it('should return false for empty array', () => {
+      registerCliModules([])
+      expect(hasCliModules()).toBe(false)
+    })
+
+    it('should return true when modules are registered', () => {
+      registerCliModules([{ id: 'some-module' }])
+      expect(hasCliModules()).toBe(true)
+    })
+  })
+
+  describe('findFrontendMatch', () => {
+    it('should match simple routes', () => {
+      const modules: Module[] = [
+        {
+          id: 'test',
+          frontendRoutes: [
+            {
+              pattern: '/dashboard',
+              Component: () => null,
+            },
+          ],
+        },
+      ]
+
+      const result = findFrontendMatch(modules, '/dashboard')
+      expect(result).toBeDefined()
+      expect(result?.params).toEqual({})
+    })
+
+    it('should match dynamic routes', () => {
+      const modules: Module[] = [
+        {
+          id: 'test',
+          frontendRoutes: [
+            {
+              pattern: '/users/[id]',
+              Component: () => null,
+            },
+          ],
+        },
+      ]
+
+      const result = findFrontendMatch(modules, '/users/123')
+      expect(result).toBeDefined()
+      expect(result?.params).toEqual({ id: '123' })
+    })
+
+    it('should match catch-all routes', () => {
+      const modules: Module[] = [
+        {
+          id: 'test',
+          frontendRoutes: [
+            {
+              pattern: '/docs/[...slug]',
+              Component: () => null,
+            },
+          ],
+        },
+      ]
+
+      const result = findFrontendMatch(modules, '/docs/api/getting-started')
+      expect(result).toBeDefined()
+      expect(result?.params).toEqual({ slug: ['api', 'getting-started'] })
+    })
+
+    it('should return undefined for non-matching routes', () => {
+      const modules: Module[] = [
+        {
+          id: 'test',
+          frontendRoutes: [
+            {
+              pattern: '/dashboard',
+              Component: () => null,
+            },
+          ],
+        },
+      ]
+
+      const result = findFrontendMatch(modules, '/settings')
+      expect(result).toBeUndefined()
+    })
+  })
+
+  describe('findBackendMatch', () => {
+    it('should match backend routes', () => {
+      const modules: Module[] = [
+        {
+          id: 'test',
+          backendRoutes: [
+            {
+              pattern: '/backend/settings',
+              Component: () => null,
+            },
+          ],
+        },
+      ]
+
+      const result = findBackendMatch(modules, '/backend/settings')
+      expect(result).toBeDefined()
+    })
+
+    it('should match dynamic backend routes', () => {
+      const modules: Module[] = [
+        {
+          id: 'test',
+          backendRoutes: [
+            {
+              pattern: '/backend/users/[id]/edit',
+              Component: () => null,
+            },
+          ],
+        },
+      ]
+
+      const result = findBackendMatch(modules, '/backend/users/456/edit')
+      expect(result).toBeDefined()
+      expect(result?.params).toEqual({ id: '456' })
+    })
+  })
+
+  describe('findApi', () => {
+    it('should find API handlers by method and path', () => {
+      const mockHandler = async () => new Response('OK')
+      const modules: Module[] = [
+        {
+          id: 'test',
+          apis: [
+            {
+              path: '/users',
+              handlers: {
+                GET: mockHandler,
+                POST: mockHandler,
+              },
+            },
+          ],
+        },
+      ]
+
+      const getResult = findApi(modules, 'GET', '/users')
+      expect(getResult).toBeDefined()
+      expect(getResult?.handler).toBe(mockHandler)
+
+      const postResult = findApi(modules, 'POST', '/users')
+      expect(postResult).toBeDefined()
+
+      const deleteResult = findApi(modules, 'DELETE', '/users')
+      expect(deleteResult).toBeUndefined()
+    })
+
+    it('should match dynamic API paths', () => {
+      const mockHandler = async () => new Response('OK')
+      const modules: Module[] = [
+        {
+          id: 'test',
+          apis: [
+            {
+              path: '/users/[id]',
+              handlers: {
+                GET: mockHandler,
+              },
+            },
+          ],
+        },
+      ]
+
+      const result = findApi(modules, 'GET', '/users/123')
+      expect(result).toBeDefined()
+      expect(result?.params).toEqual({ id: '123' })
+    })
+
+    it('should include requireAuth and requireRoles', () => {
+      const mockHandler = async () => new Response('OK')
+      const modules: Module[] = [
+        {
+          id: 'test',
+          apis: [
+            {
+              path: '/admin',
+              handlers: { GET: mockHandler },
+              requireAuth: true,
+              requireRoles: ['admin'],
+            },
+          ],
+        },
+      ]
+
+      const result = findApi(modules, 'GET', '/admin')
+      expect(result).toBeDefined()
+      expect(result?.requireAuth).toBe(true)
+      expect(result?.requireRoles).toEqual(['admin'])
+    })
+  })
+})
+
+describe('Module type with workers', () => {
+  it('should allow workers property on Module', () => {
+    const module: Module = {
+      id: 'test-module',
+      workers: [
+        {
+          id: 'test:worker',
+          queue: 'test-queue',
+          concurrency: 2,
+          handler: async () => {},
+        },
+      ],
+    }
+
+    expect(module.workers).toBeDefined()
+    expect(module.workers?.length).toBe(1)
+    expect(module.workers?.[0].queue).toBe('test-queue')
+  })
+
+  it('should allow subscribers property on Module', () => {
+    const module: Module = {
+      id: 'test-module',
+      subscribers: [
+        {
+          id: 'test:subscriber',
+          event: 'user.created',
+          handler: async () => {},
+        },
+      ],
+    }
+
+    expect(module.subscribers).toBeDefined()
+    expect(module.subscribers?.length).toBe(1)
+    expect(module.subscribers?.[0].event).toBe('user.created')
+  })
+})

package/src/modules/dashboard/widgets.ts

@@ -0,0 +1,57 @@
+import type { ComponentType } from 'react'
+
+export type DashboardWidgetSize = 'sm' | 'md' | 'lg'
+
+export type DashboardWidgetMetadata = {
+  id: string
+  title: string
+  description?: string
+  subtitle?: string
+  features?: string[]
+  defaultSize?: DashboardWidgetSize
+  defaultSettings?: unknown
+  defaultEnabled?: boolean
+  tags?: string[]
+  category?: string
+  icon?: string
+  supportsRefresh?: boolean
+}
+
+export type DashboardLayoutItem = {
+  id: string
+  widgetId: string
+  order: number
+  priority?: number
+  size?: DashboardWidgetSize
+  settings?: unknown
+}
+
+export type DashboardWidgetRenderMode = 'view' | 'settings'
+
+export type DashboardWidgetRenderContext = {
+  userId: string
+  tenantId?: string | null
+  organizationId?: string | null
+  userName?: string | null
+  userEmail?: string | null
+  userLabel?: string | null
+}
+
+export type DashboardWidgetComponentProps<TSettings = unknown> = {
+  mode: DashboardWidgetRenderMode
+  layout: DashboardLayoutItem
+  settings: TSettings
+  context: DashboardWidgetRenderContext
+  onSettingsChange: (next: TSettings) => void
+  refreshToken: number
+  onRefreshStateChange?: (refreshing: boolean) => void
+}
+
+export type DashboardWidgetModule<TSettings = unknown> = {
+  metadata: DashboardWidgetMetadata
+  Widget: ComponentType<DashboardWidgetComponentProps<TSettings>>
+  hydrateSettings?: (raw: unknown) => TSettings
+  dehydrateSettings?: (settings: TSettings) => unknown
+}
+
+export type DashboardWidgetRenderProps<TSettings = unknown> = DashboardWidgetComponentProps<TSettings>

package/src/modules/dsl.ts

@@ -0,0 +1,32 @@
+import type { CustomFieldDefinition, CustomFieldSet, EntityExtension, EntityId } from '@open-mercato/shared/modules/entities'
+
+export function entityId(moduleId: string, entity: string): EntityId {
+  return `${moduleId}:${entity}`
+}
+
+export function linkable(moduleId: string, entities: string[]): Record<string, EntityId> {
+  return Object.fromEntries(entities.map((e) => [e, entityId(moduleId, e)]))
+}
+
+export function defineLink(
+  base: EntityId,
+  extension: EntityId,
+  opts: Pick<EntityExtension, 'join' | 'cardinality' | 'required' | 'description'>
+): EntityExtension {
+  return { base, extension, ...opts }
+}
+
+export const cf = {
+  text: (key: string, opts: Omit<CustomFieldDefinition, 'key' | 'kind'> = {}): CustomFieldDefinition => ({ key, kind: 'text', ...opts }),
+  multiline: (key: string, opts: Omit<CustomFieldDefinition, 'key' | 'kind'> = {}): CustomFieldDefinition => ({ key, kind: 'multiline', ...opts }),
+  integer: (key: string, opts: Omit<CustomFieldDefinition, 'key' | 'kind'> = {}): CustomFieldDefinition => ({ key, kind: 'integer', ...opts }),
+  float: (key: string, opts: Omit<CustomFieldDefinition, 'key' | 'kind'> = {}): CustomFieldDefinition => ({ key, kind: 'float', ...opts }),
+  boolean: (key: string, opts: Omit<CustomFieldDefinition, 'key' | 'kind'> = {}): CustomFieldDefinition => ({ key, kind: 'boolean', ...opts }),
+  select: (key: string, options: string[], opts: Omit<CustomFieldDefinition, 'key' | 'kind' | 'options'> = {}): CustomFieldDefinition => ({ key, kind: 'select', options, ...opts }),
+  currency: (key: string, opts: Omit<CustomFieldDefinition, 'key' | 'kind'> = {}): CustomFieldDefinition => ({ key, kind: 'currency', ...opts }),
+  dictionary: (key: string, dictionaryId: string, opts: Omit<CustomFieldDefinition, 'key' | 'kind' | 'dictionaryId'> = {}): CustomFieldDefinition => ({ key, kind: 'dictionary', dictionaryId, ...opts }),
+}
+
+export function defineFields(entity: EntityId, fields: CustomFieldDefinition[], source?: string): CustomFieldSet {
+  return { entity, fields, source }
+}

package/src/modules/entities/__tests__/validation.test.ts

@@ -0,0 +1,52 @@
+/** @jest-environment node */
+import { validateValuesAgainstDefs } from '../validation'
+
+describe('validateValuesAgainstDefs', () => {
+  it('validates required and integer/float comparisons', () => {
+    const defs = [
+      { key: 'a', kind: 'integer', configJson: { validation: [ { rule: 'required', message: 'a required' }, { rule: 'integer', message: 'a int' }, { rule: 'gte', param: 1, message: 'a >= 1' } ] } },
+      { key: 'b', kind: 'float', configJson: { validation: [ { rule: 'float', message: 'b float' }, { rule: 'lt', param: 10, message: 'b < 10' } ] } },
+    ]
+
+    // Empty a should fail required
+    let r = validateValuesAgainstDefs({}, defs as any)
+    expect(r.ok).toBe(false)
+    expect(r.fieldErrors['cf_a']).toBe('a required')
+
+    // Non-integer a should fail integer
+    r = validateValuesAgainstDefs({ a: 1.2 }, defs as any)
+    expect(r.ok).toBe(false)
+    expect(r.fieldErrors['cf_a']).toBe('a int')
+
+    // Too-small a should fail gte
+    r = validateValuesAgainstDefs({ a: 0 }, defs as any)
+    expect(r.ok).toBe(false)
+    expect(r.fieldErrors['cf_a']).toBe('a >= 1')
+
+    // b too large should fail lt
+    r = validateValuesAgainstDefs({ a: 2, b: 11 }, defs as any)
+    expect(r.ok).toBe(false)
+    expect(r.fieldErrors['cf_b']).toBe('b < 10')
+
+    // Both valid
+    r = validateValuesAgainstDefs({ a: 2, b: 9.5 }, defs as any)
+    expect(r.ok).toBe(true)
+    expect(Object.keys(r.fieldErrors).length).toBe(0)
+  })
+
+  it('validates regex and eq/ne', () => {
+    const defs = [
+      { key: 'code', kind: 'text', configJson: { validation: [ { rule: 'regex', param: '^[a-z0-9_-]+$', message: 'bad code' } ] } },
+      { key: 'status', kind: 'select', configJson: { validation: [ { rule: 'eq', param: 'open', message: 'must be open' } ] } },
+    ]
+    let r = validateValuesAgainstDefs({ code: 'Bad!' }, defs as any)
+    expect(r.ok).toBe(false)
+    expect(r.fieldErrors['cf_code']).toBe('bad code')
+    r = validateValuesAgainstDefs({ code: 'ok', status: 'closed' }, defs as any)
+    expect(r.ok).toBe(false)
+    expect(r.fieldErrors['cf_status']).toBe('must be open')
+    r = validateValuesAgainstDefs({ code: 'ok', status: 'open' }, defs as any)
+    expect(r.ok).toBe(true)
+  })
+})
+

package/src/modules/entities/kinds.ts

@@ -0,0 +1,20 @@
+export const CUSTOM_FIELD_KINDS = [
+  'text',
+  'multiline',
+  'integer',
+  'float',
+  'boolean',
+  'select',
+  'currency',
+  'relation',
+  'attachment',
+  'dictionary',
+] as const
+
+export type CustomFieldKind = typeof CUSTOM_FIELD_KINDS[number]
+
+export function isCustomFieldKind(x: string): x is CustomFieldKind {
+  return (CUSTOM_FIELD_KINDS as readonly string[]).includes(x)
+}
+
+export const CURRENCY_OPTIONS_URL = '/api/currencies/currencies/options'

package/src/modules/entities/options.ts

@@ -0,0 +1,36 @@
+export type CustomFieldOptionInput =
+  | string
+  | {
+      value?: string | null
+      label?: string | null
+    }
+  | null
+  | undefined
+
+export type CustomFieldOptionDto = {
+  value: string
+  label: string
+}
+
+export function normalizeCustomFieldOption(option: CustomFieldOptionInput): CustomFieldOptionDto | null {
+  if (typeof option === 'string') {
+    const value = option.trim()
+    if (!value) return null
+    return { value, label: value }
+  }
+  if (!option || typeof option !== 'object') return null
+  const rawValue = typeof option.value === 'string' ? option.value.trim() : ''
+  if (!rawValue) return null
+  const rawLabel = typeof option.label === 'string' ? option.label.trim() : ''
+  return { value: rawValue, label: rawLabel || rawValue }
+}
+
+export function normalizeCustomFieldOptions(options: unknown): CustomFieldOptionDto[] {
+  if (!Array.isArray(options)) return []
+  const normalized: CustomFieldOptionDto[] = []
+  for (const entry of options) {
+    const item = normalizeCustomFieldOption(entry as CustomFieldOptionInput)
+    if (item) normalized.push(item)
+  }
+  return normalized
+}

package/src/modules/entities/validation.ts

@@ -0,0 +1,118 @@
+import { z } from 'zod'
+
+// Supported rule types for custom fields validation
+export const VALIDATION_RULES = [
+  'required',
+  'date',
+  'integer',
+  'float',
+  'lt',
+  'lte',
+  'gt',
+  'gte',
+  'eq',
+  'ne',
+  'regex',
+] as const
+
+export type ValidationRuleKind = typeof VALIDATION_RULES[number]
+
+export const validationRuleSchema = z.discriminatedUnion('rule', [
+  z.object({ rule: z.literal('required'), message: z.string().min(1) }),
+  z.object({ rule: z.literal('date'), message: z.string().min(1) }),
+  z.object({ rule: z.literal('integer'), message: z.string().min(1) }),
+  z.object({ rule: z.literal('float'), message: z.string().min(1) }),
+  z.object({ rule: z.literal('lt'), param: z.number(), message: z.string().min(1) }),
+  z.object({ rule: z.literal('lte'), param: z.number(), message: z.string().min(1) }),
+  z.object({ rule: z.literal('gt'), param: z.number(), message: z.string().min(1) }),
+  z.object({ rule: z.literal('gte'), param: z.number(), message: z.string().min(1) }),
+  z.object({ rule: z.literal('eq'), param: z.any(), message: z.string().min(1) }),
+  z.object({ rule: z.literal('ne'), param: z.any(), message: z.string().min(1) }),
+  z.object({ rule: z.literal('regex'), param: z.string().min(1), message: z.string().min(1) }),
+])
+
+export type ValidationRule = z.infer<typeof validationRuleSchema>
+
+export const validationRulesArraySchema = z.array(validationRuleSchema).max(32)
+
+export type CustomFieldDefLike = {
+  key: string
+  kind: string
+  configJson?: any
+}
+
+// Evaluate a single rule against a value
+function evalRule(rule: ValidationRule, value: any, kind: string): string | null {
+  const isEmpty = (v: any) => v == null || (typeof v === 'string' && v.trim() === '') || (Array.isArray(v) && v.length === 0)
+
+  switch (rule.rule) {
+    case 'required':
+      return isEmpty(value) ? rule.message : null
+    case 'date': {
+      if (isEmpty(value)) return null
+      const d = new Date(String(value))
+      return isNaN(d.getTime()) ? rule.message : null
+    }
+    case 'integer': {
+      if (isEmpty(value)) return null
+      const n = Number(value)
+      return Number.isInteger(n) ? null : rule.message
+    }
+    case 'float': {
+      if (isEmpty(value)) return null
+      const n = Number(value)
+      return Number.isFinite(n) ? null : rule.message
+    }
+    case 'lt':
+      if (isEmpty(value)) return null
+      return Number(value) < (rule as any).param ? null : rule.message
+    case 'lte':
+      if (isEmpty(value)) return null
+      return Number(value) <= (rule as any).param ? null : rule.message
+    case 'gt':
+      if (isEmpty(value)) return null
+      return Number(value) > (rule as any).param ? null : rule.message
+    case 'gte':
+      if (isEmpty(value)) return null
+      return Number(value) >= (rule as any).param ? null : rule.message
+    case 'eq':
+      if (isEmpty(value)) return null
+      return value === (rule as any).param ? null : rule.message
+    case 'ne':
+      if (isEmpty(value)) return null
+      return value !== (rule as any).param ? null : rule.message
+    case 'regex':
+      if (isEmpty(value)) return null
+      try {
+        const re = new RegExp((rule as any).param)
+        return re.test(String(value)) ? null : rule.message
+      } catch {
+        // Invalid regex in definition: consider it failed safe and return message
+        return rule.message
+      }
+    default:
+      return null
+  }
+}
+
+export function validateValuesAgainstDefs(
+  values: Record<string, any>,
+  defs: CustomFieldDefLike[],
+): { ok: boolean; fieldErrors: Record<string, string> } {
+  const errors: Record<string, string> = {}
+  for (const def of defs) {
+    const cfg = def?.configJson || {}
+    const rules: ValidationRule[] = Array.isArray(cfg.validation) ? cfg.validation : []
+    if (rules.length === 0) continue
+    const value = values[def.key]
+    for (const r of rules) {
+      const msg = evalRule(r as any, value, def.kind)
+      if (msg) {
+        errors[`cf_${def.key}`] = msg
+        break
+      }
+    }
+  }
+  return { ok: Object.keys(errors).length === 0, fieldErrors: errors }
+}
+