@open-mercato/shared 0.4.2-canary-c02407ff85

package/src/lib/location/countries.ts

@@ -0,0 +1,97 @@
+import registry from 'language-subtag-registry/data/json/registry.json'
+
+type RegistryEntry = {
+  Type: string
+  Subtag?: string
+  Description?: string[]
+  Deprecated?: string
+}
+
+export type IsoCountry = {
+  code: string
+  name: string
+}
+
+function isIsoAlpha2(entry: RegistryEntry): entry is RegistryEntry & { Subtag: string; Description: string[] } {
+  if (entry.Type !== 'region') return false
+  if (!entry.Subtag || !/^[A-Z]{2}$/.test(entry.Subtag)) return false
+  if (entry.Deprecated) return false
+  if (!entry.Description || !entry.Description.length) return false
+  if (entry.Description[0] === 'Private use') return false
+  return true
+}
+
+const RAW_COUNTRIES: IsoCountry[] = (registry as RegistryEntry[])
+  .filter(isIsoAlpha2)
+  .map((entry) => ({
+    code: entry.Subtag,
+    name: entry.Description.join(', '),
+  }))
+
+export const ISO_COUNTRIES: IsoCountry[] = [...RAW_COUNTRIES].sort((a, b) =>
+  a.name.localeCompare(b.name, 'en', { sensitivity: 'base' })
+)
+
+export const COUNTRY_PRIORITY: string[] = ['PL', 'DE', 'ES', 'FR', 'IT', 'US', 'GB', 'CA']
+
+const displayNameCache = new Map<string, Intl.DisplayNames>()
+
+function getDisplayNames(locale: string): Intl.DisplayNames | null {
+  if (typeof Intl === 'undefined' || typeof Intl.DisplayNames === 'undefined') return null
+  const key = locale || 'en'
+  let instance = displayNameCache.get(key)
+  if (!instance) {
+    try {
+      instance = new Intl.DisplayNames([key], { type: 'region' })
+      displayNameCache.set(key, instance)
+    } catch {
+      return null
+    }
+  }
+  return instance
+}
+
+export function resolveCountryName(code: string, options: { locale?: string } = {}): string {
+  const normalized = code.toUpperCase()
+  const fallback = ISO_COUNTRIES.find((entry) => entry.code === normalized)?.name ?? normalized
+  const displayNames = getDisplayNames(options.locale ?? 'en')
+  if (!displayNames) return fallback
+  try {
+    const label = displayNames.of(normalized as any)
+    return typeof label === 'string' ? label : fallback
+  } catch {
+    return fallback
+  }
+}
+
+export function buildCountryOptions(options: {
+  locale?: string
+  priority?: string[]
+  transformLabel?: (code: string, defaultLabel: string) => string
+} = {}): Array<{ code: string; label: string }> {
+  const { locale, transformLabel } = options
+  const priority = (options.priority ?? COUNTRY_PRIORITY).map((code) => code.toUpperCase())
+  const prioritySet = new Set(priority)
+  const labelFor = (code: string) => {
+    const base = resolveCountryName(code, { locale })
+    return transformLabel ? transformLabel(code, base) : base
+  }
+
+  const byCode = new Map(ISO_COUNTRIES.map((entry) => [entry.code, entry]))
+
+  const prioritized = priority
+    .map((code) => {
+      const base = byCode.get(code)
+      if (!base) return null
+      return { code, label: labelFor(code) }
+    })
+    .filter((entry): entry is { code: string; label: string } => !!entry)
+    .sort((a, b) => a.label.localeCompare(b.label, locale ?? 'en', { sensitivity: 'base' }))
+
+  const remaining = ISO_COUNTRIES
+    .filter((entry) => !prioritySet.has(entry.code))
+    .map((entry) => ({ code: entry.code, label: labelFor(entry.code) }))
+    .sort((a, b) => a.label.localeCompare(b.label, locale ?? 'en', { sensitivity: 'base' }))
+
+  return [...prioritized, ...remaining]
+}

package/src/lib/modules/index.ts

@@ -0,0 +1 @@
+export { registerModules, getModules } from './registry'

package/src/lib/modules/registry.ts

@@ -0,0 +1,18 @@
+import type { Module } from '@open-mercato/shared/modules/registry'
+
+// Registration pattern for publishable packages
+let _modules: Module[] | null = null
+
+export function registerModules(modules: Module[]) {
+  if (_modules !== null && process.env.NODE_ENV === 'development') {
+    console.debug('[Bootstrap] Modules re-registered (this may occur during HMR)')
+  }
+  _modules = modules
+}
+
+export function getModules(): Module[] {
+  if (!_modules) {
+    throw new Error('[Bootstrap] Modules not registered. Call registerModules() at bootstrap.')
+  }
+  return _modules
+}

package/src/lib/openapi/crud.ts

@@ -0,0 +1,218 @@
+import { z, type ZodTypeAny } from 'zod'
+import type { OpenApiRouteDoc } from './types'
+
+export const defaultCreateResponseSchema = z.object({ id: z.string().uuid().nullable() })
+export const defaultOkResponseSchema = z.object({ ok: z.literal(true) })
+
+export type PagedListResponseOptions = {
+  paginationMetaOptional?: boolean
+}
+
+export function createPagedListResponseSchema(itemSchema: ZodTypeAny, options: PagedListResponseOptions = {}) {
+  const paginationMetaOptional = options.paginationMetaOptional ?? false
+
+  return z.object({
+    items: z.array(itemSchema),
+    total: z.number(),
+    page: paginationMetaOptional ? z.number().optional() : z.number(),
+    pageSize: paginationMetaOptional ? z.number().optional() : z.number(),
+    totalPages: z.number(),
+  })
+}
+
+type CrudMethodConfig = {
+  schema: ZodTypeAny
+  description?: string
+  responseSchema?: ZodTypeAny
+}
+
+type CrudCreateConfig = CrudMethodConfig & {
+  status?: number
+}
+
+type CrudDeleteConfig = {
+  schema?: ZodTypeAny
+  description?: string
+  responseSchema?: ZodTypeAny
+}
+
+export type CrudOpenApiOptions = {
+  tag?: string
+  resourceName: string
+  pluralName?: string
+  description?: string
+  querySchema?: ZodTypeAny
+  listResponseSchema: ZodTypeAny
+  create?: CrudCreateConfig
+  update?: CrudMethodConfig
+  del?: CrudDeleteConfig
+}
+
+export type CrudTextContext = {
+  resourceName: string
+  resourceLower: string
+  pluralName: string
+  pluralLower: string
+}
+
+export type CrudOpenApiFactoryConfig = {
+  defaultTag: string
+  defaultCreateResponseSchema?: ZodTypeAny
+  defaultOkResponseSchema?: ZodTypeAny
+  makeListDescription?: (ctx: CrudTextContext) => string
+  makeCreateDescription?: (ctx: CrudTextContext) => string
+  makeCreateRequestBodyDescription?: (ctx: CrudTextContext) => string
+  makeUpdateDescription?: (ctx: CrudTextContext) => string
+  makeUpdateRequestBodyDescription?: (ctx: CrudTextContext) => string
+  makeDeleteDescription?: (ctx: CrudTextContext) => string
+  makeDeleteRequestBodyDescription?: (ctx: CrudTextContext) => string
+}
+
+function resolveDefault(
+  factory: ((ctx: CrudTextContext) => string) | undefined,
+  ctx: CrudTextContext,
+  fallback: string,
+) {
+  if (typeof factory === 'function') return factory(ctx)
+  return fallback
+}
+
+export function createCrudOpenApiFactory(config: CrudOpenApiFactoryConfig) {
+  return function createCrudOpenApi(options: CrudOpenApiOptions): OpenApiRouteDoc {
+    const {
+      resourceName,
+      pluralName,
+      tag,
+      description,
+      querySchema,
+      listResponseSchema,
+      create,
+      update,
+      del,
+    } = options
+
+    const plural = pluralName ?? `${resourceName}s`
+    const resourceLower = resourceName.toLowerCase()
+    const pluralLower = plural.toLowerCase()
+    const context: CrudTextContext = {
+      resourceName,
+      resourceLower,
+      pluralName: plural,
+      pluralLower,
+    }
+
+    const fallbackCreateResponseSchema = config.defaultCreateResponseSchema ?? defaultCreateResponseSchema
+    const fallbackOkResponseSchema = config.defaultOkResponseSchema ?? defaultOkResponseSchema
+
+    const methods: NonNullable<OpenApiRouteDoc['methods']> = {}
+
+    methods.GET = {
+      summary: `List ${pluralLower}`,
+      description:
+        description ?? resolveDefault(config.makeListDescription, context, `Returns a paginated collection of ${pluralLower}.`),
+      query: querySchema,
+      responses: [
+        {
+          status: 200,
+          description: `Paginated ${pluralLower}`,
+          schema: listResponseSchema,
+        },
+      ],
+    }
+
+    if (create) {
+      const createDescription =
+        create.description ??
+        resolveDefault(config.makeCreateDescription, context, `Creates a new ${resourceLower}.`)
+
+      const createBodyDescription =
+        resolveDefault(
+          config.makeCreateRequestBodyDescription,
+          context,
+          create.description ?? `Payload describing the ${resourceLower} to create.`,
+        )
+
+      methods.POST = {
+        summary: `Create ${resourceLower}`,
+        description: createDescription,
+        requestBody: {
+          schema: create.schema,
+          description: createBodyDescription,
+        },
+        responses: [
+          {
+            status: create.status ?? 201,
+            description: `${resourceName} created`,
+            schema: create.responseSchema ?? fallbackCreateResponseSchema,
+          },
+        ],
+      }
+    }
+
+    if (update) {
+      const updateDescription =
+        update.description ??
+        resolveDefault(config.makeUpdateDescription, context, `Updates an existing ${resourceLower} by id.`)
+
+      const updateBodyDescription =
+        resolveDefault(
+          config.makeUpdateRequestBodyDescription,
+          context,
+          update.description ?? `Fields to update on the ${resourceLower}.`,
+        )
+
+      methods.PUT = {
+        summary: `Update ${resourceLower}`,
+        description: updateDescription,
+        requestBody: {
+          schema: update.schema,
+          description: updateBodyDescription,
+        },
+        responses: [
+          {
+            status: 200,
+            description: `${resourceName} updated`,
+            schema: update.responseSchema ?? fallbackOkResponseSchema,
+          },
+        ],
+      }
+    }
+
+    if (del) {
+      const deleteDescription =
+        del.description ??
+        resolveDefault(config.makeDeleteDescription, context, `Deletes a ${resourceLower} identified by id.`)
+
+      const deleteBodyDescription =
+        resolveDefault(
+          config.makeDeleteRequestBodyDescription,
+          context,
+          del.description ?? 'Identifier payload.',
+        )
+
+      methods.DELETE = {
+        summary: `Delete ${resourceLower}`,
+        description: deleteDescription,
+        requestBody: del.schema
+          ? {
+              schema: del.schema,
+              description: deleteBodyDescription,
+            }
+          : undefined,
+        responses: [
+          {
+            status: 200,
+            description: `${resourceName} deleted`,
+            schema: del.responseSchema ?? fallbackOkResponseSchema,
+          },
+        ],
+      }
+    }
+
+    return {
+      tag: tag ?? config.defaultTag,
+      summary: `${resourceName} management`,
+      methods,
+    }
+  }
+}