@open-mercato/shared 0.4.2-canary-c02407ff85

package/src/lib/i18n/context.tsx

@@ -0,0 +1,66 @@
+"use client"
+import React, { createContext, useContext, useMemo } from 'react'
+import type { Locale } from './config'
+
+export type Dict = Record<string, string>
+
+export type TranslateParams = Record<string, string | number>
+
+export type TranslateFn = (
+  key: string,
+  fallbackOrParams?: string | TranslateParams,
+  params?: TranslateParams
+) => string
+
+export type I18nContextValue = {
+  locale: Locale
+  t: TranslateFn
+}
+
+const I18nContext = createContext<I18nContextValue | null>(null)
+
+function format(template: string, params?: TranslateParams) {
+  if (!params) return template
+  return template.replace(/\{\{(\w+)\}\}|\{(\w+)\}/g, (_, doubleKey, singleKey) => {
+    const key = doubleKey ?? singleKey
+    if (!key) return _
+    const value = params[key]
+    if (value === undefined) {
+      return doubleKey ? `{{${key}}}` : `{${key}}`
+    }
+    return String(value)
+  })
+}
+
+export function I18nProvider({ children, locale, dict }: { children: React.ReactNode; locale: Locale; dict: Dict }) {
+  const value = useMemo<I18nContextValue>(() => ({
+    locale,
+    t: (key, fallbackOrParams, params) => {
+      let fallback: string | undefined
+      let resolvedParams: TranslateParams | undefined
+
+      if (typeof fallbackOrParams === 'string') {
+        fallback = fallbackOrParams
+        resolvedParams = params
+      } else {
+        resolvedParams = fallbackOrParams ?? params
+      }
+
+      const template = dict[key] ?? fallback ?? key
+      return format(template, resolvedParams)
+    },
+  }), [locale, dict])
+  return <I18nContext.Provider value={value}>{children}</I18nContext.Provider>
+}
+
+export function useT() {
+  const ctx = useContext(I18nContext)
+  if (!ctx) throw new Error('useT must be used within I18nProvider')
+  return ctx.t
+}
+
+export function useLocale() {
+  const ctx = useContext(I18nContext)
+  if (!ctx) throw new Error('useLocale must be used within I18nProvider')
+  return ctx.locale
+}

package/src/lib/i18n/server.ts

@@ -0,0 +1,74 @@
+import { defaultLocale, locales, type Locale } from './config'
+import type { Dict } from './context'
+import { createFallbackTranslator, createTranslator } from './translate'
+import { getModules } from '../modules/registry'
+import { loadAppDictionary } from './app-dictionaries'
+
+// Re-export for backwards compatibility
+export { registerModules, getModules } from '../modules/registry'
+export { registerAppDictionaryLoader } from './app-dictionaries'
+
+function flattenDictionary(source: unknown, prefix = ''): Dict {
+  if (!source || typeof source !== 'object' || Array.isArray(source)) return {}
+  const result: Dict = {}
+  for (const [key, value] of Object.entries(source as Record<string, unknown>)) {
+    if (!key) continue
+    const nextKey = prefix ? `${prefix}.${key}` : key
+    if (typeof value === 'string') {
+      result[nextKey] = value
+    } else if (value && typeof value === 'object' && !Array.isArray(value)) {
+      Object.assign(result, flattenDictionary(value, nextKey))
+    }
+  }
+  return result
+}
+
+export async function detectLocale(): Promise<Locale> {
+  // Dynamic import to avoid requiring Next.js in non-Next.js contexts (CLI, tests)
+  try {
+    const { cookies, headers } = await import('next/headers')
+    try {
+      const c = (await cookies()).get('locale')?.value
+      if (c && locales.includes(c as Locale)) return c as Locale
+    } catch {
+      // cookies() may not be available outside request context (e.g., in tests)
+    }
+    try {
+      const accept = (await headers()).get('accept-language') || ''
+      const match = locales.find(l => new RegExp(`(^|,)\\s*${l}(-|;|,|$)`, 'i').test(accept))
+      if (match) return match
+    } catch {
+      // headers() may not be available outside request context (e.g., in tests)
+    }
+  } catch {
+    // next/headers not available (CLI context)
+  }
+  return defaultLocale
+}
+
+export async function loadDictionary(locale: Locale): Promise<Dict> {
+  // Load from registry instead of @/ import (works in standalone packages)
+  const baseRaw = await loadAppDictionary(locale)
+  const merged: Dict = { ...flattenDictionary(baseRaw) }
+  const modules = getModules()
+  for (const m of modules) {
+    const dict = m.translations?.[locale]
+    if (dict) Object.assign(merged, flattenDictionary(dict))
+  }
+  return merged
+}
+
+export async function resolveTranslations() {
+  const locale = await detectLocale()
+  const dict = await loadDictionary(locale)
+  const t = createTranslator(dict)
+  const translate = createFallbackTranslator(dict)
+  return { locale, dict, t, translate }
+}
+// Hint Next.js to keep this server-only; ignore if unavailable when running scripts outside Next.
+try {
+  // eslint-disable-next-line @typescript-eslint/no-var-requires
+  require('server-only')
+} catch {
+  // noop: allows running generator scripts without Next's server-only package
+}

package/src/lib/i18n/translate.ts

@@ -0,0 +1,54 @@
+import type { Dict, TranslateFn, TranslateParams } from './context'
+
+export type TranslateWithFallbackFn = (key: string, fallback?: string, params?: TranslateParams) => string
+
+function format(template: string, params?: TranslateParams) {
+  if (!params) return template
+  return template.replace(/\{\{(\w+)\}\}|\{(\w+)\}/g, (match, doubleKey, singleKey) => {
+    const key = doubleKey ?? singleKey
+    if (!key) return match
+    const value = params[key]
+    if (value === undefined) return match
+    return String(value)
+  })
+}
+
+export function createTranslator(dict: Dict): TranslateFn {
+  const translator = ((key: string, fallbackOrParams?: string | TranslateParams, params?: TranslateParams) => {
+    let fallback: string | undefined
+    let resolvedParams: TranslateParams | undefined
+
+    if (typeof fallbackOrParams === 'string') {
+      fallback = fallbackOrParams
+      resolvedParams = params
+    } else {
+      resolvedParams = fallbackOrParams
+    }
+
+    const template = dict[key] ?? fallback ?? key
+    return format(template, resolvedParams)
+  }) as TranslateFn
+
+  return translator
+}
+
+export function translateWithFallback(
+  t: TranslateFn,
+  key: string,
+  fallback?: string,
+  params?: TranslateParams,
+): string {
+  const value = params ? t(key, params) : t(key)
+  if (value !== key) return value
+  if (fallback === undefined) return key
+  return format(fallback, params)
+}
+
+export function createTranslatorWithFallback(translate: TranslateFn): TranslateWithFallbackFn {
+  return (key, fallback, params) => translateWithFallback(translate, key, fallback, params)
+}
+
+export function createFallbackTranslator(dict: Dict): TranslateWithFallbackFn {
+  const t = createTranslator(dict)
+  return (key, fallback, params) => translateWithFallback(t, key, fallback, params)
+}

package/src/lib/indexers/error-log.ts

@@ -0,0 +1,106 @@
+import type { EntityManager } from '@mikro-orm/postgresql'
+import type { Knex } from 'knex'
+
+export type IndexerErrorSource = 'query_index' | 'vector' | 'fulltext'
+
+export type RecordIndexerErrorInput = {
+  source: IndexerErrorSource
+  handler: string
+  error: unknown
+  entityType?: string | null
+  recordId?: string | null
+  tenantId?: string | null
+  organizationId?: string | null
+  payload?: unknown
+}
+
+type RecordIndexerErrorDeps = {
+  em?: EntityManager
+  knex?: Knex
+}
+
+const MAX_MESSAGE_LENGTH = 8_192
+const MAX_STACK_LENGTH = 32_768
+
+function truncate(input: string | null | undefined, limit: number): string | null {
+  if (!input) return null
+  return input.length > limit ? `${input.slice(0, limit - 3)}...` : input
+}
+
+function normalizeError(error: unknown): { message: string; stack: string | null } {
+  if (error instanceof Error) {
+    return {
+      message: error.message || error.name || 'Unknown error',
+      stack: typeof error.stack === 'string' ? error.stack : null,
+    }
+  }
+  if (typeof error === 'string') {
+    return { message: error, stack: null }
+  }
+  try {
+    const json = JSON.stringify(error)
+    return { message: json, stack: null }
+  } catch {
+    return { message: String(error ?? 'Unknown error'), stack: null }
+  }
+}
+
+function safeJson(value: unknown): unknown {
+  if (value === undefined) return null
+  try {
+    return JSON.parse(JSON.stringify(value))
+  } catch {
+    if (value == null) return null
+    if (typeof value === 'object') {
+      return { note: 'unserializable', asString: String(value) }
+    }
+    return value
+  }
+}
+
+function pickKnex(deps: RecordIndexerErrorDeps): Knex | null {
+  if (deps.knex) return deps.knex
+  if (deps.em) {
+    try {
+      const connection = deps.em.getConnection()
+      if (connection && typeof connection.getKnex === 'function') {
+        return connection.getKnex()
+      }
+    } catch {
+      return null
+    }
+  }
+  return null
+}
+
+export async function recordIndexerError(deps: RecordIndexerErrorDeps, input: RecordIndexerErrorInput): Promise<void> {
+  const knex = pickKnex(deps)
+  if (!knex) {
+    console.error('[indexers] Unable to record indexer error (missing knex connection)', {
+      source: input.source,
+      handler: input.handler,
+    })
+    return
+  }
+
+  const { message, stack } = normalizeError(input.error)
+  const payload = safeJson(input.payload)
+  const now = new Date()
+
+  try {
+    await knex('indexer_error_logs').insert({
+      source: input.source,
+      handler: input.handler,
+      entity_type: input.entityType ?? null,
+      record_id: input.recordId ?? null,
+      tenant_id: input.tenantId ?? null,
+      organization_id: input.organizationId ?? null,
+      payload,
+      message: truncate(message, MAX_MESSAGE_LENGTH),
+      stack: truncate(stack, MAX_STACK_LENGTH),
+      occurred_at: now,
+    })
+  } catch (loggingError) {
+    console.error('[indexers] Failed to persist indexer error', loggingError)
+  }
+}

package/src/lib/indexers/status-log.ts

@@ -0,0 +1,119 @@
+import type { EntityManager } from '@mikro-orm/postgresql'
+import type { Knex } from 'knex'
+import type { IndexerErrorSource } from './error-log'
+
+export type IndexerLogLevel = 'info' | 'warn'
+
+export type RecordIndexerLogInput = {
+  source: IndexerErrorSource
+  handler: string
+  message: string
+  level?: IndexerLogLevel
+  entityType?: string | null
+  recordId?: string | null
+  tenantId?: string | null
+  organizationId?: string | null
+  details?: unknown
+}
+
+type RecordIndexerLogDeps = {
+  em?: EntityManager
+  knex?: Knex
+}
+
+const MAX_MESSAGE_LENGTH = 4_096
+const MAX_DELETE_BATCH = 5_000
+const MAX_LOGS_PER_SOURCE = 10_000
+
+function truncate(input: string | null | undefined, limit: number): string | null {
+  if (!input) return null
+  return input.length > limit ? `${input.slice(0, limit - 3)}...` : input
+}
+
+function safeJson(value: unknown): unknown {
+  if (value === undefined) return null
+  try {
+    return JSON.parse(JSON.stringify(value))
+  } catch {
+    if (value == null) return null
+    if (typeof value === 'object') {
+      return { note: 'unserializable', asString: String(value) }
+    }
+    return value
+  }
+}
+
+function pickKnex(deps: RecordIndexerLogDeps): Knex | null {
+  if (deps.knex) return deps.knex
+  if (deps.em) {
+    try {
+      const connection = deps.em.getConnection()
+      if (connection && typeof connection.getKnex === 'function') {
+        return connection.getKnex()
+      }
+    } catch {
+      return null
+    }
+  }
+  return null
+}
+
+async function pruneExcessLogs(knex: Knex, source: IndexerErrorSource): Promise<void> {
+  const rows = await knex('indexer_status_logs')
+    .select('id')
+    .where('source', source)
+    .orderBy('occurred_at', 'desc')
+    .orderBy('id', 'desc')
+    .offset(MAX_LOGS_PER_SOURCE)
+    .limit(MAX_DELETE_BATCH)
+
+  if (!rows.length) return
+  const ids = rows.map((row: any) => row.id).filter(Boolean)
+  if (!ids.length) return
+  await knex('indexer_status_logs')
+    .whereIn('id', ids)
+    .del()
+}
+
+export async function recordIndexerLog(
+  deps: RecordIndexerLogDeps,
+  input: RecordIndexerLogInput,
+): Promise<void> {
+  const knex = pickKnex(deps)
+  if (!knex) {
+    console.warn('[indexers] Unable to record indexer log (missing knex connection)', {
+      source: input.source,
+      handler: input.handler,
+    })
+    return
+  }
+
+  const level: IndexerLogLevel = input.level === 'warn' ? 'warn' : 'info'
+  const message = truncate(input.message, MAX_MESSAGE_LENGTH) ?? '—'
+  const details = safeJson(input.details)
+  const occurredAt = new Date()
+
+  try {
+    await knex('indexer_status_logs').insert({
+      source: input.source,
+      handler: input.handler,
+      level,
+      entity_type: input.entityType ?? null,
+      record_id: input.recordId ?? null,
+      tenant_id: input.tenantId ?? null,
+      organization_id: input.organizationId ?? null,
+      message,
+      details,
+      occurred_at: occurredAt,
+    })
+  } catch (error) {
+    console.error('[indexers] Failed to persist indexer log', error)
+    return
+  }
+
+  try {
+    await pruneExcessLogs(knex, input.source)
+  } catch (pruneError) {
+    console.warn('[indexers] Failed to prune indexer logs', pruneError)
+  }
+}

package/src/lib/lib/auth/jwt.ts

@@ -0,0 +1,39 @@
+import crypto from 'node:crypto'
+
+function base64url(input: Buffer | string) {
+  return (typeof input === 'string' ? Buffer.from(input) : input)
+    .toString('base64')
+    .replace(/=/g, '')
+    .replace(/\+/g, '-')
+    .replace(/\//g, '_')
+}
+
+export type JwtPayload = Record<string, any>
+
+export function signJwt(payload: JwtPayload, secret = process.env.JWT_SECRET!, expiresInSec = 60 * 60 * 8) {
+  if (!secret) throw new Error('JWT_SECRET is not set')
+  const header = { alg: 'HS256', typ: 'JWT' }
+  const now = Math.floor(Date.now() / 1000)
+  const body = { iat: now, exp: now + expiresInSec, ...payload }
+  const encHeader = base64url(JSON.stringify(header))
+  const encBody = base64url(JSON.stringify(body))
+  const data = `${encHeader}.${encBody}`
+  const sig = crypto.createHmac('sha256', secret).update(data).digest()
+  const encSig = base64url(sig)
+  return `${data}.${encSig}`
+}
+
+export function verifyJwt(token: string, secret = process.env.JWT_SECRET!) {
+  if (!secret) throw new Error('JWT_SECRET is not set')
+  const parts = token.split('.')
+  if (parts.length !== 3) return null
+  const [h, p, s] = parts
+  const data = `${h}.${p}`
+  const expected = base64url(crypto.createHmac('sha256', secret).update(data).digest())
+  if (!crypto.timingSafeEqual(Buffer.from(s), Buffer.from(expected))) return null
+  const payload = JSON.parse(Buffer.from(p, 'base64').toString('utf8'))
+  const now = Math.floor(Date.now() / 1000)
+  if (payload.exp && now > payload.exp) return null
+  return payload
+}
+

package/src/lib/lib/auth/server.ts

@@ -0,0 +1,94 @@
+import { cookies } from 'next/headers'
+import type { EntityManager } from '@mikro-orm/postgresql'
+import { verifyJwt } from './jwt'
+
+export type AuthContext = {
+  sub: string
+  tenantId: string | null
+  orgId: string | null
+  email?: string
+  roles?: string[]
+  isApiKey?: boolean
+  keyId?: string
+  keyName?: string
+  [k: string]: any
+} | null
+
+async function resolveApiKeyAuth(secret: string): Promise<AuthContext> {
+  if (!secret) return null
+  try {
+    const { createRequestContainer } = await import('@open-mercato/shared/lib/di/container')
+    const container = await createRequestContainer()
+    const em = (container.resolve('em') as EntityManager)
+    const { findApiKeyBySecret } = await import('@open-mercato/core/modules/api_keys/services/apiKeyService')
+    const { Role } = await import('@open-mercato/core/modules/auth/data/entities')
+
+    const record = await findApiKeyBySecret(em, secret)
+    if (!record) return null
+
+    const roleIds = Array.isArray(record.rolesJson) ? record.rolesJson : []
+    const roles = roleIds.length
+      ? await em.find(Role, { id: { $in: roleIds as any } } as any)
+      : []
+    const roleNames = roles.map((role) => role.name).filter((name): name is string => typeof name === 'string' && name.length > 0)
+
+    try {
+      record.lastUsedAt = new Date()
+      await em.persistAndFlush(record)
+    } catch {}
+
+    return {
+      sub: `api_key:${record.id}`,
+      tenantId: record.tenantId ?? null,
+      orgId: record.organizationId ?? null,
+      roles: roleNames,
+      isApiKey: true,
+      keyId: record.id,
+      keyName: record.name,
+    }
+  } catch {
+    return null
+  }
+}
+
+function extractApiKey(req: Request): string | null {
+  const header = (req.headers.get('x-api-key') || '').trim()
+  if (header) return header
+  const authHeader = (req.headers.get('authorization') || '').trim()
+  if (authHeader.toLowerCase().startsWith('apikey ')) {
+    return authHeader.slice(7).trim()
+  }
+  return null
+}
+
+export async function getAuthFromCookies(): Promise<AuthContext> {
+  const token = (await cookies()).get('auth_token')?.value
+  if (!token) return null
+  try {
+    const payload = verifyJwt(token)
+    return payload
+  } catch {
+    return null
+  }
+}
+
+export async function getAuthFromRequest(req: Request): Promise<AuthContext> {
+  const authHeader = (req.headers.get('authorization') || '').trim()
+  let token: string | undefined
+  if (authHeader.toLowerCase().startsWith('bearer ')) token = authHeader.slice(7).trim()
+  if (!token) {
+    const cookie = req.headers.get('cookie') || ''
+    const match = cookie.match(/(?:^|;\s*)auth_token=([^;]+)/)
+    if (match) token = decodeURIComponent(match[1])
+  }
+  if (token) {
+    try {
+      const payload = verifyJwt(token)
+      if (payload) return payload
+    } catch {}
+  }
+
+  const apiKey = extractApiKey(req)
+  if (!apiKey) return null
+  return resolveApiKeyAuth(apiKey)
+}

package/src/lib/lib/email/send.ts

@@ -0,0 +1,18 @@
+import { Resend } from 'resend'
+import React from 'react'
+
+export type SendEmailOptions = {
+  to: string
+  subject: string
+  react: React.ReactElement
+  from?: string
+}
+
+export async function sendEmail({ to, subject, react, from }: SendEmailOptions) {
+  const apiKey = process.env.RESEND_API_KEY
+  if (!apiKey) throw new Error('RESEND_API_KEY is not set')
+  const resend = new Resend(apiKey)
+  const fromAddr = from || process.env.EMAIL_FROM || 'no-reply@localhost'
+  await resend.emails.send({ to, subject, from: fromAddr, react })
+}
+

package/src/lib/lib/i18n/config.ts

@@ -0,0 +1,4 @@
+export type Locale = 'en' | 'pl' | 'es' | 'de'
+
+export const locales: Locale[] = ['en', 'pl', 'es', 'de']
+export const defaultLocale: Locale = 'en'

package/src/lib/lib/i18n/context.tsx

@@ -0,0 +1,38 @@
+"use client"
+import React, { createContext, useContext, useMemo } from 'react'
+import type { Locale } from './config'
+
+export type Dict = Record<string, string>
+
+export type I18nContextValue = {
+  locale: Locale
+  t: (key: string, params?: Record<string, string | number>) => string
+}
+
+const I18nContext = createContext<I18nContextValue | null>(null)
+
+function format(template: string, params?: Record<string, string | number>) {
+  if (!params) return template
+  return template.replace(/\{(\w+)\}/g, (_, k) => String(params[k] ?? `{${k}}`))
+}
+
+export function I18nProvider({ children, locale, dict }: { children: React.ReactNode; locale: Locale; dict: Dict }) {
+  const value = useMemo<I18nContextValue>(() => ({
+    locale,
+    t: (key, params) => format(dict[key] ?? key, params),
+  }), [locale, dict])
+  return <I18nContext.Provider value={value}>{children}</I18nContext.Provider>
+}
+
+export function useT() {
+  const ctx = useContext(I18nContext)
+  if (!ctx) throw new Error('useT must be used within I18nProvider')
+  return ctx.t
+}
+
+export function useLocale() {
+  const ctx = useContext(I18nContext)
+  if (!ctx) throw new Error('useLocale must be used within I18nProvider')
+  return ctx.locale
+}
+

package/src/lib/lib/utils.ts

@@ -0,0 +1,6 @@
+import { clsx, type ClassValue } from "clsx"
+import { twMerge } from "tailwind-merge"
+
+export function cn(...inputs: ClassValue[]) {
+  return twMerge(clsx(inputs))
+}