sovrium 0.0.2

package/src/application/use-cases/server/static-url-rewriter.ts

@@ -0,0 +1,237 @@
+/**
+ * Copyright (c) 2025 ESSENTIAL SERVICES
+ *
+ * This source code is licensed under the Business Source License 1.1
+ * found in the LICENSE.md file in the root directory of this source tree.
+ */
+
+/* eslint-disable max-params, max-lines-per-function -- Complex URL rewriting functions require explicit dependencies */
+
+import { Effect, Console } from 'effect'
+import { StaticGenerationError } from '@/application/errors/static-generation-error'
+import type { FileSystemLike, PathModuleLike } from './generate-static-helpers'
+
+/**
+ * Check if a URL is a GitHub Pages URL
+ * Security: Use proper hostname checking to avoid substring matching vulnerabilities
+ */
+export const isGitHubPagesUrl = (url: string): boolean => {
+  try {
+    const { hostname } = new URL(url)
+    return hostname === 'github.io' || hostname.endsWith('.github.io')
+  } catch {
+    return false
+  }
+}
+
+/**
+ * Rewrite URLs in HTML content with base path prefix
+ *
+ * Rewrites:
+ * - href="/..." → href="/basePath/..."
+ * - src="/..." → src="/basePath/..."
+ * - Adds canonical link if missing (when baseUrl is provided)
+ * - Skips URLs that already have base path
+ * - Skips external URLs (http://, https://, //, etc.)
+ */
+export const rewriteUrlsWithBasePath = (
+  html: string,
+  basePath: string,
+  baseUrl?: string,
+  pagePath?: string
+): string => {
+  // Remove trailing slash from basePath if present
+  const normalizedBasePath = basePath.endsWith('/') ? basePath.slice(0, -1) : basePath
+
+  // Extract base path without language code for assets
+  // If basePath is "/my-project/en", extract "/my-project" for assets
+  const basePathWithoutLang = normalizedBasePath.replace(/\/[a-z]{2}$/, '')
+
+  // Rewrite href="/..." to href="/basePath/..."
+  // But for /assets/*, use only the base path without language code
+  // Also handle hreflang alternate links specially (they should link to other languages)
+  const hrefRewritten = html.replace(
+    /(hrefLang|hreflang)="([^"]*)"[^>]*href="(\/[^"]*)"/g,
+    (_match, _hreflangAttr, langCode, url) => {
+      // For hreflang links, extract language from URL and construct correct path
+      // Example: href="/en/" → href="https://baseUrl/my-project/en/"
+      // Convert hrefLang to lowercase hreflang for standards compliance
+      const normalizedAttr = 'hreflang'
+      // Extract short code from full locale (e.g., "en-US" → "en")
+      const shortCode = langCode.split('-')[0]
+      // hreflang URLs should include full base URL
+      const fullUrl = baseUrl ? `${baseUrl}${url}` : `${basePathWithoutLang}${url}`
+      return `${normalizedAttr}="${shortCode}" href="${fullUrl}"`
+    }
+  )
+
+  // Now rewrite remaining href attributes (non-hreflang)
+  const allHrefRewritten = hrefRewritten.replace(
+    /(?<!hreflang=")href="(\/[^"]*)"/g,
+    (_match, url) => {
+      if (url.startsWith('/assets/')) {
+        // Assets are shared across languages - use base path only
+        return `href="${basePathWithoutLang}${url}"`
+      }
+      return `href="${normalizedBasePath}${url}"`
+    }
+  )
+
+  // Rewrite src="/..." to src="/basePath/..."
+  // Assets paths should not include language prefix
+  const srcRewritten = allHrefRewritten.replace(/src="(\/[^"]*)"/g, (_match, url) => {
+    if (url.startsWith('/assets/')) {
+      // Assets are shared across languages - use base path only
+      return `src="${basePathWithoutLang}${url}"`
+    }
+    return `src="${normalizedBasePath}${url}"`
+  })
+
+  // Add canonical link if missing and baseUrl is provided
+  if (baseUrl && pagePath && !srcRewritten.includes('rel="canonical"')) {
+    // Construct canonical URL from baseUrl + pagePath
+    // Remove trailing slash from baseUrl for consistent URLs
+    const normalizedBaseUrl = baseUrl.endsWith('/') ? baseUrl.slice(0, -1) : baseUrl
+    const canonicalPath = pagePath === '/' ? '/' : pagePath
+    const canonicalUrl = `${normalizedBaseUrl}${canonicalPath}`
+
+    // Insert canonical link in <head> before </head>
+    return srcRewritten.replace('</head>', `<link rel="canonical" href="${canonicalUrl}"></head>`)
+  }
+
+  return srcRewritten
+}
+
+/**
+ * Rewrite URLs in HTML files with base path
+ */
+export const rewriteBasePathInHtml = (
+  generatedFiles: readonly string[],
+  outputDir: string,
+  basePath: string,
+  baseUrl: string | undefined,
+  fsModule: FileSystemLike
+): Effect.Effect<void, StaticGenerationError, never> =>
+  Effect.gen(function* () {
+    yield* Console.log(`🔗 Rewriting URLs with base path: ${basePath}...`)
+    // Only rewrite actual page HTML files, not assets with .html extension
+    const htmlFiles = generatedFiles.filter(
+      (f) =>
+        f.endsWith('.html') &&
+        !f.startsWith('assets/') &&
+        !f.includes('/assets/') &&
+        !f.endsWith('.js.html')
+    )
+
+    yield* Effect.forEach(
+      htmlFiles,
+      (file) =>
+        Effect.gen(function* () {
+          // file might be absolute or relative - handle both cases
+          const filePath =
+            file.startsWith('/') || file.startsWith(outputDir) ? file : `${outputDir}/${file}`
+
+          const content = yield* Effect.tryPromise({
+            try: () => fsModule.readFile(filePath, 'utf-8'),
+            catch: (error) =>
+              new StaticGenerationError({
+                message: `Failed to read HTML file: ${file}`,
+                cause: error,
+              }),
+          })
+
+          // Determine page path from filename (index.html → /, about.html → /about)
+          const relativeFile = file.startsWith(outputDir) ? file.slice(outputDir.length + 1) : file
+
+          // Check if this file is in a language subdirectory (e.g., en/index.html, fr/about.html)
+          const langMatch = relativeFile.match(/^([a-z]{2})\//)
+          const langPrefix = langMatch ? `/${langMatch[1]}` : ''
+
+          // Extract page path without language prefix
+          const fileWithoutLang = langPrefix ? relativeFile.slice(3) : relativeFile // Skip "en/"
+          const basePagePath =
+            fileWithoutLang === 'index.html' ? '/' : `/${fileWithoutLang.replace('.html', '')}`
+
+          // Full page path includes basePath + language prefix
+          const fullBasePath = `${basePath}${langPrefix}`
+
+          // For canonical URL, use the page path relative to baseUrl
+          // If baseUrl includes the basePath (e.g., https://example.com/myapp),
+          // we should use basePagePath directly
+          const canonicalPagePath =
+            basePagePath === '/'
+              ? langPrefix === ''
+                ? '/'
+                : langPrefix
+              : `${langPrefix}${basePagePath}`
+
+          const rewrittenContent = rewriteUrlsWithBasePath(
+            content,
+            fullBasePath,
+            baseUrl,
+            canonicalPagePath
+          )
+
+          yield* Effect.tryPromise({
+            try: () => fsModule.writeFile(filePath, rewrittenContent, 'utf-8'),
+            catch: (error) =>
+              new StaticGenerationError({
+                message: `Failed to write rewritten HTML file: ${file}`,
+                cause: error,
+              }),
+          })
+        }),
+      { concurrency: 'unbounded' }
+    )
+  })
+
+/**
+ * Inject client-side hydration script into HTML files
+ */
+export const injectHydrationScript = (
+  generatedFiles: readonly string[],
+  outputDir: string,
+  basePath: string,
+  fsModule: FileSystemLike,
+  pathModule: PathModuleLike
+): Effect.Effect<void, StaticGenerationError, never> =>
+  Effect.gen(function* () {
+    yield* Console.log('💧 Injecting hydration script into HTML files...')
+    const htmlFiles = generatedFiles.filter(
+      (f) =>
+        f.endsWith('.html') &&
+        !f.endsWith('.js.html') &&
+        !f.startsWith('assets/') &&
+        !f.includes('/assets/')
+    )
+
+    yield* Effect.forEach(
+      htmlFiles,
+      (file) =>
+        Effect.gen(function* () {
+          const filePath = file.startsWith('/') ? file : pathModule.join(outputDir, file)
+          const content = yield* Effect.tryPromise({
+            try: () => fsModule.readFile(filePath, 'utf-8'),
+            catch: (error) =>
+              new StaticGenerationError({
+                message: `Failed to read HTML file for hydration injection: ${file}`,
+                cause: error,
+              }),
+          })
+
+          // Inject hydration script before </body>
+          const hydrationScript = `<script src="${basePath}/assets/client.js" defer=""></script>`
+          const updatedContent = content.replace('</body>', `${hydrationScript}\n</body>`)
+
+          yield* Effect.tryPromise({
+            try: () => fsModule.writeFile(filePath, updatedContent, 'utf-8'),
+            catch: (error) =>
+              new StaticGenerationError({
+                message: `Failed to write HTML file with hydration script: ${file}`,
+                cause: error,
+              }),
+          })
+        }),
+      { concurrency: 'unbounded' }
+    )
+  })

package/src/application/use-cases/server/translation-replacer.ts

@@ -0,0 +1,164 @@
+/**
+ * Copyright (c) 2025 ESSENTIAL SERVICES
+ *
+ * This source code is licensed under the Business Source License 1.1
+ * found in the LICENSE.md file in the root directory of this source tree.
+ */
+
+import { resolveTranslation } from '@/domain/utils/translation-resolver'
+import type { App, Page } from '@/domain/models/app'
+import type { LanguageConfig } from '@/domain/models/app/language/language-config'
+import type { Languages } from '@/domain/models/app/languages'
+
+/**
+ * Context for token replacement operations
+ */
+type TokenReplacementContext = {
+  readonly langCode: string
+  readonly langConfig: LanguageConfig
+  readonly languages: Languages | undefined
+  readonly translations: Record<string, string>
+  readonly currentPath?: string // Optional current page path for {{currentPath}} replacement
+}
+
+/**
+ * Replace translation tokens in a string
+ *
+ * Replaces $t:key patterns with translations from the centralized translations dictionary.
+ * Also replaces {{currentPath}} with the current page path.
+ * Uses the same resolution logic as dynamic rendering (with fallback support).
+ *
+ * @param str - String potentially containing $t:key or {{currentPath}} patterns
+ * @param context - Token replacement context
+ * @returns String with all patterns resolved
+ *
+ * @example
+ * ```typescript
+ * replaceTokens('$t:welcome', context)  // 'Welcome' (or 'Bienvenue' for fr)
+ * replaceTokens('$t:goodbye', context)  // Falls back to default if missing
+ * replaceTokens('/en{{currentPath}}', { ...context, currentPath: '/about' })  // '/en/about'
+ * replaceTokens('Hello world', context) // 'Hello world' (no pattern)
+ * ```
+ */
+function replaceTokens(str: string, context: TokenReplacementContext): string {
+  // Replace $t: translation pattern
+  const translatedStr = str.startsWith('$t:')
+    ? resolveTranslation(str.slice(3), context.langCode, context.languages)
+    : str
+
+  // Replace {{currentPath}} pattern (for language switcher hrefs)
+  const currentPath = context.currentPath || '/'
+  return translatedStr.replace(/\{\{currentPath\}\}/g, currentPath)
+}
+
+/**
+ * Replace tokens in any value (recursively handles objects, arrays, strings)
+ */
+function replaceTokensInValue(value: unknown, context: TokenReplacementContext): unknown {
+  if (typeof value === 'string') {
+    return replaceTokens(value, context)
+  }
+
+  if (Array.isArray(value)) {
+    return value.map((item) => replaceTokensInValue(item, context))
+  }
+
+  if (value !== null && typeof value === 'object') {
+    return Object.fromEntries(
+      Object.entries(value).map(([key, val]) => [key, replaceTokensInValue(val, context)])
+    )
+  }
+
+  return value
+}
+
+/**
+ * Replace translation tokens in page meta and set lang attribute programmatically
+ *
+ * Sets meta.lang to the full locale (e.g., 'en-US', 'fr-FR') without using tokens.
+ * Then resolves any $t: patterns in the remaining meta fields.
+ */
+function replaceMetaTokens(meta: Page['meta'], context: TokenReplacementContext): Page['meta'] {
+  if (!meta) return meta
+
+  // Set lang to full locale programmatically (not via token)
+  const locale = context.langConfig.locale || context.langCode
+  const metaWithLang = {
+    ...meta,
+    lang: locale,
+  }
+
+  // Resolve $t: patterns in remaining meta fields
+  return replaceTokensInValue(metaWithLang, context) as Page['meta']
+}
+
+/**
+ * Replace translation tokens in a page configuration
+ *
+ * Resolves $t:key patterns throughout the page and sets meta.lang programmatically.
+ * Also replaces {{currentPath}} patterns in language switcher hrefs.
+ *
+ * @param page - Page with potential $t:key translation tokens
+ * @param context - Token replacement context
+ * @returns Page with all $t: patterns resolved
+ */
+export function replacePageTokens(page: Page, context: TokenReplacementContext): Page {
+  const pageContext: TokenReplacementContext = {
+    ...context,
+    currentPath: page.path, // Pass current page path for {{currentPath}} replacement
+  }
+
+  // Replace tokens in everything except meta
+  const { meta, ...restOfPage } = page
+  const replacedRest = replaceTokensInValue(restOfPage, pageContext) as Omit<Page, 'meta'>
+
+  // Replace meta separately with special lang handling
+  const replacedMeta = replaceMetaTokens(meta, pageContext)
+
+  return {
+    ...replacedRest,
+    meta: replacedMeta,
+  } as Page
+}
+
+/**
+ * Replace translation tokens in app configuration for a specific language
+ *
+ * Resolves all $t:key patterns throughout the app for static site generation.
+ * This is a pure function that performs token replacement without throwing exceptions.
+ * Callers should validate language codes before calling this function.
+ *
+ * @param app - App configuration (may contain $t:key tokens in pages)
+ * @param langCode - Language code to generate for (e.g., 'en', 'fr')
+ * @returns App with all $t: patterns resolved for the language
+ * @internal This function assumes langCode exists in supported languages
+ */
+export function replaceAppTokens(app: App, langCode: string): App {
+  // If no languages configured, return app as-is
+  if (!app.languages) {
+    return app
+  }
+
+  // Find language config - caller must ensure langCode is valid
+  const langConfig = app.languages.supported.find((lang) => lang.code === langCode)!
+
+  // Get translations for this language
+  const translations = app.languages.translations?.[langCode] || {}
+
+  // Create context for token replacement
+  const context: TokenReplacementContext = {
+    langCode,
+    langConfig,
+    languages: app.languages,
+    translations,
+  }
+
+  // Replace tokens in pages (with currentPath resolution)
+  const pages = app.pages?.map((page) => replacePageTokens(page, context))
+
+  // Return app with replaced pages
+  return {
+    ...app,
+    pages,
+  }
+}

package/src/application/use-cases/tables/activity-programs.ts

@@ -0,0 +1,93 @@
+/**
+ * Copyright (c) 2025 ESSENTIAL SERVICES
+ *
+ * This source code is licensed under the Business Source License 1.1
+ * found in the LICENSE.md file in the root directory of this source tree.
+ */
+
+import { Effect } from 'effect'
+import { ActivityRepository } from '@/application/ports/repositories/activity-repository'
+import { SessionContextError } from '@/domain/errors'
+import type { UserMetadataWithImage } from '@/application/ports/models/user-metadata'
+import type { UserSession } from '@/application/ports/models/user-session'
+import type { ActivityHistoryEntry } from '@/application/ports/repositories/activity-repository'
+
+/**
+ * Get record history configuration
+ */
+interface GetRecordHistoryConfig {
+  readonly session: Readonly<UserSession>
+  readonly tableName: string
+  readonly recordId: string
+  readonly limit?: number
+  readonly offset?: number
+}
+
+/**
+ * Format activity history entry for API response
+ */
+function formatActivityEntry(entry: ActivityHistoryEntry) {
+  return {
+    action: entry.action,
+    createdAt: entry.createdAt.toISOString(),
+    changes: entry.changes,
+    user: entry.user,
+  }
+}
+
+/**
+ * Get record history program
+ */
+export function getRecordHistoryProgram(config: GetRecordHistoryConfig): Effect.Effect<
+  {
+    readonly history: readonly {
+      readonly action: string
+      readonly createdAt: string
+      readonly changes: unknown
+      readonly user: UserMetadataWithImage | undefined
+    }[]
+    readonly pagination: {
+      readonly limit: number
+      readonly offset: number
+      readonly total: number
+    }
+  },
+  SessionContextError,
+  ActivityRepository
+> {
+  return Effect.gen(function* () {
+    const activityRepo = yield* ActivityRepository
+    const { session, tableName, recordId, limit, offset } = config
+
+    // Check if record exists in the table (handles live records)
+    const recordExists = yield* activityRepo.checkRecordExists({ session, tableName, recordId })
+
+    // Fetch activity history with pagination (needed even for deleted records)
+    const { entries, total } = yield* activityRepo.getRecordHistory({
+      session,
+      tableName,
+      recordId,
+      limit,
+      offset,
+    })
+
+    // If record doesn't exist in table AND has no activity logs, it truly doesn't exist
+    if (!recordExists && total === 0) {
+      return yield* Effect.fail(new SessionContextError('Record not found'))
+    }
+
+    // Resolve pagination values (default: all results)
+    const resolvedLimit = limit ?? total
+    const resolvedOffset = offset ?? 0
+
+    // Format response
+    return {
+      history: entries.map(formatActivityEntry),
+      pagination: {
+        limit: resolvedLimit,
+        offset: resolvedOffset,
+        total,
+      },
+    }
+  })
+}

package/src/application/use-cases/tables/batch-operations.ts

@@ -0,0 +1,156 @@
+/**
+ * Copyright (c) 2025 ESSENTIAL SERVICES
+ *
+ * This source code is licensed under the Business Source License 1.1
+ * found in the LICENSE.md file in the root directory of this source tree.
+ */
+
+import { Effect } from 'effect'
+import {
+  BatchRepository,
+  type BatchValidationError,
+} from '@/application/ports/repositories/batch-repository'
+import { transformRecords, type TransformedRecord } from './utils/record-transformer'
+import type { UserSession } from '@/application/ports/models/user-session'
+import type { SessionContextError, ValidationError } from '@/domain/errors'
+import type { BatchRestoreRecordsResponse } from '@/domain/models/api/tables'
+import type { App } from '@/domain/models/app'
+
+export function batchCreateProgram(config: {
+  readonly session: Readonly<UserSession>
+  readonly tableName: string
+  readonly recordsData: readonly Record<string, unknown>[]
+  readonly returnRecords?: boolean
+  readonly app?: App
+}): Effect.Effect<
+  { readonly created: number; readonly records?: readonly TransformedRecord[] },
+  SessionContextError | ValidationError,
+  BatchRepository
+> {
+  const { session, tableName, recordsData, returnRecords = false, app } = config
+  return Effect.gen(function* () {
+    const batch = yield* BatchRepository
+
+    // Create records in the database
+    const createdRecords = yield* batch.batchCreate(session, tableName, recordsData)
+
+    // Transform records to API format with app schema for numeric coercion
+    const transformed = transformRecords(createdRecords, { app, tableName })
+
+    // Use functional pattern to build response object
+    const response: { readonly created: number; readonly records?: readonly TransformedRecord[] } =
+      returnRecords
+        ? {
+            created: transformed.length,
+            records: transformed as TransformedRecord[],
+          }
+        : {
+            created: transformed.length,
+          }
+
+    return response
+  })
+}
+
+export function batchUpdateProgram(config: {
+  readonly session: Readonly<UserSession>
+  readonly tableName: string
+  readonly recordsData: readonly {
+    readonly id: string
+    readonly fields?: Record<string, unknown>
+  }[]
+  readonly returnRecords?: boolean
+  readonly app?: App
+}): Effect.Effect<
+  { readonly updated: number; readonly records?: readonly TransformedRecord[] },
+  SessionContextError | ValidationError,
+  BatchRepository
+> {
+  const { session, tableName, recordsData, returnRecords = false, app } = config
+  return Effect.gen(function* () {
+    const batch = yield* BatchRepository
+    const updatedRecords = yield* batch.batchUpdate(session, tableName, recordsData)
+
+    // Transform records to API format with app schema for numeric coercion
+    const transformed = transformRecords(updatedRecords, { app, tableName })
+
+    // Use functional pattern to build response object
+    const response: { readonly updated: number; readonly records?: readonly TransformedRecord[] } =
+      returnRecords
+        ? {
+            updated: transformed.length,
+            records: transformed as TransformedRecord[],
+          }
+        : {
+            updated: transformed.length,
+          }
+
+    return response
+  })
+}
+
+export function batchDeleteProgram(
+  session: Readonly<UserSession>,
+  tableName: string,
+  ids: readonly string[],
+  permanent = false
+): Effect.Effect<{ deleted: number }, SessionContextError, BatchRepository> {
+  return Effect.gen(function* () {
+    const batch = yield* BatchRepository
+    const deletedCount = yield* batch.batchDelete(session, tableName, ids, permanent)
+    return {
+      deleted: deletedCount,
+    }
+  })
+}
+
+export function batchRestoreProgram(
+  session: Readonly<UserSession>,
+  tableName: string,
+  ids: readonly string[]
+): Effect.Effect<BatchRestoreRecordsResponse, SessionContextError, BatchRepository> {
+  return Effect.gen(function* () {
+    const batch = yield* BatchRepository
+    const restored = yield* batch.batchRestore(session, tableName, ids)
+    return {
+      success: true as const,
+      restored,
+    }
+  })
+}
+
+export function upsertProgram(
+  session: Readonly<UserSession>,
+  tableName: string,
+  params: {
+    readonly recordsData: readonly Record<string, unknown>[]
+    readonly fieldsToMergeOn: readonly string[]
+    readonly returnRecords: boolean
+    readonly app?: App
+  }
+): Effect.Effect<
+  {
+    readonly records: readonly TransformedRecord[]
+    readonly created: number
+    readonly updated: number
+  },
+  SessionContextError | ValidationError | BatchValidationError,
+  BatchRepository
+> {
+  return Effect.gen(function* () {
+    const batch = yield* BatchRepository
+    const result = yield* batch.upsert(
+      session,
+      tableName,
+      params.recordsData,
+      params.fieldsToMergeOn
+    )
+
+    const transformed = transformRecords(result.records, { app: params.app, tableName })
+    return {
+      records: transformed,
+      created: result.created,
+      updated: result.updated,
+    }
+  })
+}