@open-mercato/shared 0.6.8-develop.6930.1.1e5976efc3 → 0.6.8-develop.6940.1.177ea30c6e

package/src/lib/crud/factory.ts

@@ -236,9 +236,13 @@ export type ListConfig<TList> = {
   buildFilters?: (query: TList, ctx: CrudCtx) => Where<any> | Promise<Where<any>>
   transformItem?: (item: any) => any
   allowCsv?: boolean
+  // The function forms mirror `fields` above: a route whose export columns depend
+  // on per-request state (for example custom-field definitions discovered in
+  // `beforeList`) MUST resolve them from `ctx` rather than from module-level
+  // mutable state, which would bleed one tenant's columns into another's export.
   csv?: {
-    headers: string[]
-    row: (item: any) => (string | number | boolean | null | undefined)[]
+    headers: string[] | ((query: TList, ctx: CrudCtx) => string[])
+    row: (item: any, ctx: CrudCtx) => (string | number | boolean | null | undefined)[]
     filename?: string
   }
   export?: CrudExportOptions
@@ -347,14 +351,20 @@ function buildExportFromColumns(items: any[], columnsConfig: CrudExportColumnCon
   }
 }
 
-function buildExportFromCsv(items: any[], csv: NonNullable<ListConfig<any>['csv']>): PreparedExport {
+function buildExportFromCsv(
+  items: any[],
+  csv: NonNullable<ListConfig<any>['csv']>,
+  query: unknown,
+  ctx: CrudCtx,
+): PreparedExport {
   const used = new Set<string>()
-  const columns = csv.headers.map((header, idx) => ({
+  const resolvedHeaders = typeof csv.headers === 'function' ? csv.headers(query as any, ctx) : csv.headers
+  const columns = resolvedHeaders.map((header, idx) => ({
     field: sanitizeFieldName(header || `column_${idx + 1}`, used, idx),
     header: header || `Column ${idx + 1}`,
   }))
   const rows = items.map((item) => {
-    const values = csv.row(item) || []
+    const values = csv.row(item, ctx) || []
     const row: Record<string, unknown> = {}
     columns.forEach((column, idx) => {
       row[column.field] = values[idx]
@@ -377,12 +387,12 @@ function buildDefaultExport(items: any[]): PreparedExport {
   }
 }
 
-function prepareExportData(items: any[], list: ListConfig<any>): PreparedExport {
+function prepareExportData(items: any[], list: ListConfig<any>, query: unknown, ctx: CrudCtx): PreparedExport {
   if (list.export?.columns && list.export.columns.length > 0) {
     return buildExportFromColumns(items, list.export.columns)
   }
   if (list.csv) {
-    return buildExportFromCsv(items, list.csv)
+    return buildExportFromCsv(items, list.csv, query, ctx)
   }
   const prepared = buildDefaultExport(items)
   return {
@@ -1890,7 +1900,7 @@ export function makeCrudRoute<TCreate = any, TUpdate = any, TList = any>(opts: C
           }
           const prepared = exportFullRequested
             ? { columns: ensureColumns(exportItems), rows: exportItems }
-            : prepareExportData(exportItems, opts.list)
+            : prepareExportData(exportItems, opts.list, validated as any, ctx)
           const fallbackBase = `${opts.events?.entity || resourceKind || 'list'}${exportFullRequested ? '_full' : ''}`
           const filename = finalizeExportFilename(opts.list, requestedExport, fallbackBase)
           const serialized = serializeExport(prepared, requestedExport)
@@ -2092,7 +2102,7 @@ export function makeCrudRoute<TCreate = any, TUpdate = any, TList = any>(opts: C
         const exportItems = exportFullRequested ? list.map(normalizeFullRecordForExport) : list
         const prepared = exportFullRequested
           ? { columns: ensureColumns(exportItems), rows: exportItems }
-          : prepareExportData(exportItems, opts.list)
+          : prepareExportData(exportItems, opts.list, validated as any, ctx)
         const fallbackBase = `${opts.events?.entity || resourceKind || 'list'}${exportFullRequested ? '_full' : ''}`
         const filename = finalizeExportFilename(opts.list, requestedExport, fallbackBase)
         const serialized = serializeExport(prepared, requestedExport)

package/src/lib/openapi/__tests__/response-precedence.test.ts

@@ -0,0 +1,150 @@
+import { z } from 'zod'
+import { buildOpenApiDocument } from '../generator'
+import type { Module, ModuleApiRouteFile } from '../../../modules/registry'
+import type { OpenApiMethodDoc } from '../types'
+
+type ResponseEntry = {
+  description?: string
+  content?: Record<string, { schema?: { properties?: Record<string, unknown> } }>
+  'x-autoGenerated'?: boolean
+}
+
+type Operation = { responses: Record<string, ResponseEntry> }
+
+const errorSchema = z.object({ error: z.string(), code: z.string() })
+const routePath = '/example/records'
+const guardedMetadata = { GET: { requireAuth: true, requireFeatures: ['example.records.view'] } }
+
+function makeModule(methodDoc: OpenApiMethodDoc, metadata: ModuleApiRouteFile['metadata']): Module {
+  const api: ModuleApiRouteFile = {
+    path: routePath,
+    metadata,
+    handlers: { GET: async () => new Response(null) },
+    docs: { tag: 'Example', methods: { GET: methodDoc } },
+  }
+  return { id: 'example', apis: [api] }
+}
+
+function getOperationWithMetadata(
+  methodDoc: OpenApiMethodDoc,
+  metadata: ModuleApiRouteFile['metadata']
+): Operation {
+  const doc = buildOpenApiDocument([makeModule(methodDoc, metadata)])
+  return doc.paths[routePath]?.get as Operation
+}
+
+function getOperation(methodDoc: OpenApiMethodDoc): Operation {
+  return getOperationWithMetadata(methodDoc, guardedMetadata)
+}
+
+function jsonSchemaProperties(entry: ResponseEntry): Record<string, unknown> | undefined {
+  return entry.content?.['application/json']?.schema?.properties
+}
+
+describe('buildResponses precedence between declared and inferred responses', () => {
+  it('keeps a 403 declared through responses instead of the requireFeatures default', () => {
+    const operation = getOperation({
+      responses: [
+        { status: 200, description: 'Records', schema: z.object({ items: z.array(z.string()) }) },
+        { status: 403, description: 'Record is outside the active scope', schema: errorSchema },
+      ],
+    })
+
+    expect(operation.responses['403'].description).toBe('Record is outside the active scope')
+    expect(operation.responses['403']['x-autoGenerated']).toBeUndefined()
+    expect(jsonSchemaProperties(operation.responses['403'])?.code).toBeDefined()
+  })
+
+  it('keeps a 403 declared through errors instead of the requireFeatures default', () => {
+    const operation = getOperation({
+      responses: [{ status: 200, description: 'Records' }],
+      errors: [{ status: 403, description: 'Record is outside the active scope', schema: errorSchema }],
+    })
+
+    expect(operation.responses['403'].description).toBe('Record is outside the active scope')
+    expect(operation.responses['403']['x-autoGenerated']).toBeUndefined()
+    expect(jsonSchemaProperties(operation.responses['403'])?.code).toBeDefined()
+  })
+
+  it('keeps a 401 declared through errors instead of the requireAuth default', () => {
+    const operation = getOperation({
+      responses: [{ status: 200, description: 'Records' }],
+      errors: [{ status: 401, description: 'Session token expired', schema: errorSchema }],
+    })
+
+    expect(operation.responses['401'].description).toBe('Session token expired')
+    expect(operation.responses['401']['x-autoGenerated']).toBeUndefined()
+  })
+
+  it('keeps a 401 declared through responses instead of the requireAuth default', () => {
+    const operation = getOperation({
+      responses: [
+        { status: 200, description: 'Records' },
+        { status: 401, description: 'Session token expired', schema: errorSchema },
+      ],
+    })
+
+    expect(operation.responses['401'].description).toBe('Session token expired')
+    expect(operation.responses['401']['x-autoGenerated']).toBeUndefined()
+  })
+
+  it('emits both inferred entries when the route documents neither status', () => {
+    const operation = getOperation({
+      responses: [{ status: 200, description: 'Records' }],
+      errors: [{ status: 404, description: 'Not found', schema: errorSchema }],
+    })
+
+    expect(operation.responses['401'].description).toBe('Unauthorized')
+    expect(operation.responses['401']['x-autoGenerated']).toBe(true)
+    expect(operation.responses['403'].description).toBe('Forbidden – missing required features')
+    expect(operation.responses['403']['x-autoGenerated']).toBe(true)
+    expect(operation.responses['404'].description).toBe('Not found')
+    expect(operation.responses['404']['x-autoGenerated']).toBeUndefined()
+  })
+
+  it('mixes a declared 403 with the inferred 401 on the same operation', () => {
+    const operation = getOperation({
+      responses: [{ status: 200, description: 'Records' }],
+      errors: [{ status: 403, description: 'Record is outside the active scope', schema: errorSchema }],
+    })
+
+    expect(operation.responses['403']['x-autoGenerated']).toBeUndefined()
+    expect(operation.responses['401']['x-autoGenerated']).toBe(true)
+  })
+
+  it('still synthesises the success response when the route declares only errors', () => {
+    const operation = getOperation({
+      errors: [{ status: 403, description: 'Record is outside the active scope', schema: errorSchema }],
+    })
+
+    expect(operation.responses['200'].description).toBe('Success response')
+    expect(operation.responses['403'].description).toBe('Record is outside the active scope')
+  })
+
+  it('infers nothing when the route declares no auth or feature metadata', () => {
+    const operation = getOperationWithMetadata({ responses: [{ status: 200, description: 'Records' }] }, undefined)
+
+    expect(Object.keys(operation.responses)).toEqual(['200'])
+  })
+
+  it('infers only the 401 when the route requires auth without features', () => {
+    const operation = getOperationWithMetadata({ responses: [{ status: 200, description: 'Records' }] }, {
+      GET: { requireAuth: true },
+    })
+
+    expect(operation.responses['401']['x-autoGenerated']).toBe(true)
+    expect(operation.responses['403']).toBeUndefined()
+  })
+
+  it('pins the documented last-wins behaviour when responses and errors collide on one status', () => {
+    const operation = getOperation({
+      responses: [
+        { status: 200, description: 'Records' },
+        { status: 409, description: 'Declared through responses', schema: errorSchema },
+      ],
+      errors: [{ status: 409, description: 'Declared through errors', schema: errorSchema }],
+    })
+
+    expect(operation.responses['409'].description).toBe('Declared through errors')
+  })
+})

package/src/lib/openapi/generator.ts

@@ -785,8 +785,9 @@ function buildResponses(
   const entries: Record<string, unknown> = {}
   const list = [...(responses ?? [])]
   const errorList = [...(errors ?? [])]
+  const inferredList: OpenApiResponseDoc[] = []
   if (metadata?.requireAuth) {
-    errorList.push({
+    inferredList.push({
       status: 401,
       description: 'Unauthorized',
       schema: z.object({ error: z.string() }),
@@ -794,7 +795,7 @@ function buildResponses(
     })
   }
   if (Array.isArray(metadata?.requireFeatures) && metadata.requireFeatures.length) {
-    errorList.push({
+    inferredList.push({
       status: 403,
       description: 'Forbidden – missing required features',
       schema: z.object({ error: z.string() }),
@@ -808,8 +809,9 @@ function buildResponses(
       description: fallbackStatus === 204 ? 'Success' : 'Success response',
     })
   }
-  for (const res of [...list, ...errorList]) {
+  const setEntry = (res: OpenApiResponseDoc, options?: { skipIfPresent?: boolean }) => {
     const status = String(res.status || 200)
+    if (options?.skipIfPresent && Object.prototype.hasOwnProperty.call(entries, status)) return
     const mediaType = res.mediaType ?? 'application/json'
     const schema = res.schema ? zodToJsonSchema(res.schema) : undefined
     const example = res.schema ? res.example ?? generateExample(res.schema) : res.example
@@ -829,6 +831,8 @@ function buildResponses(
       ...(res.xAutoGenerated ? { 'x-autoGenerated': true } : {}),
     }
   }
+  for (const res of [...list, ...errorList]) setEntry(res)
+  for (const res of inferredList) setEntry(res, { skipIfPresent: true })
   return entries
 }
 

package/src/lib/query/__tests__/engine.test.ts

@@ -12,6 +12,17 @@ beforeEach(() => {
 // Mock modules with one entity extension
 const mockModules = [
   { id: 'auth', entityExtensions: [ { base: 'auth:user', extension: 'my_module:user_profile', join: { baseKey: 'id', extensionKey: 'user_id' } } ] },
+  {
+    id: 'example',
+    entityExtensions: [
+      // Declares `table` explicitly; the derived plural now agrees with it.
+      { base: 'customers:customer_entity', extension: 'example:example_customer_priority', join: { baseKey: 'id', extensionKey: 'customer_id' }, table: 'example_customer_priorities' },
+      // No `table`: exercises the derived-plural fallback.
+      { base: 'auth:role', extension: 'example:example_role_policy', join: { baseKey: 'id', extensionKey: 'role_id' } },
+      // `table` is not a bare identifier, so the engine must refuse it.
+      { base: 'auth:session', extension: 'example:example_session_note', join: { baseKey: 'id', extensionKey: 'session_id' }, table: 'notes"; drop table users --' },
+    ],
+  },
 ]
 
 // Register modules for the registration-based pattern
@@ -1072,3 +1083,54 @@ describe('BasicQueryEngine (Kysely)', () => {
     })
   })
 })
+
+describe('BasicQueryEngine entity-extension joins', () => {
+  function extensionJoins(fakeDb: any, baseTable: string): any[] {
+    const baseCall = fakeDb._calls.find((builder: any) => builder._ops.table === baseTable)
+    expect(baseCall).toBeTruthy()
+    return baseCall._ops.joins.filter((entry: any) => Object.keys(entry.aliasObj)[0].startsWith('ext_'))
+  }
+
+  async function joinFor(entity: string, baseTable: string): Promise<any> {
+    const fakeDb = createFakeKysely()
+    const engine = new BasicQueryEngine({} as any, () => fakeDb as any)
+    await engine.query(entity, {
+      tenantId: 't1',
+      organizationId: 'org1',
+      fields: ['id'],
+      includeExtensions: true,
+    })
+    const joins = extensionJoins(fakeDb, baseTable)
+    expect(joins).toHaveLength(1)
+    return joins[0]
+  }
+
+  test('prefers a declared table over the derived plural', async () => {
+    const join = await joinFor('customers:customer_entity', 'customer_entities')
+    expect(join.aliasObj).toEqual({ ext_example_customer_priority: 'example_customer_priorities' })
+    expect(join.conditions).toEqual([
+      {
+        method: 'on',
+        args: ['ext_example_customer_priority.customer_id', '=', 'customer_entities.id'],
+      },
+    ])
+  })
+
+  test('falls back to the derived plural when no table is declared', async () => {
+    // `policy` ends in `y`, so the correct plural is `policies`. This previously asserted
+    // `policys`, pinning a separate inline `+s` pluralizer that the extension-join path used
+    // instead of the file's own `pluralizeBaseName` — the very bug that made
+    // `example_customer_priority` derive `example_customer_prioritys` and forced the
+    // `table` override into existence.
+    const join = await joinFor('auth:role', 'roles')
+    expect(join.aliasObj).toEqual({ ext_example_role_policy: 'example_role_policies' })
+    expect(join.conditions).toEqual([
+      { method: 'on', args: ['ext_example_role_policy.role_id', '=', 'roles.id'] },
+    ])
+  })
+
+  test('ignores a declared table that is not a bare identifier', async () => {
+    const join = await joinFor('auth:session', 'sessions')
+    expect(join.aliasObj).toEqual({ ext_example_session_note: 'example_session_notes' })
+  })
+})

package/src/lib/query/engine.ts

@@ -72,6 +72,16 @@ const pluralizeBaseName = (name: string): string => {
   return `${name}s`
 }
 
+/**
+ * Accepts a module-declared `EntityExtension.table` only when it is a bare SQL
+ * identifier. The value is interpolated into a join clause, so anything else is
+ * ignored in favour of the derived table name.
+ */
+const PLAIN_TABLE_IDENTIFIER_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/
+
+const isPlainTableIdentifier = (value: unknown): value is string =>
+  typeof value === 'string' && PLAIN_TABLE_IDENTIFIER_PATTERN.test(value)
+
 const toPascalCase = (value: string): string => {
   return value
     .split(/[_\s]+/)
@@ -955,7 +965,15 @@ export class BasicQueryEngine implements QueryEngine {
           : exts
         for (const e of chosen) {
           const [, extName] = (e.extension as string).split(':')
-          const extTable = extName.endsWith('s') ? extName : `${extName}s`
+          // Uses the SAME derivation as every other table-name fallback in this file
+          // (`pluralizeBaseName`, also called at the resolveEntityTableName sites above)
+          // rather than a separate inline one. The inline version handled only `+s`, so
+          // `example_customer_priority` derived `example_customer_prioritys` against the
+          // real `example_customer_priorities`. Behaviour is unchanged for every name that
+          // does not end in `y`; `table` below remains the escape hatch for irregular
+          // plurals no guesser can win (`person` → `people`).
+          const derivedTable = pluralizeBaseName(extName)
+          const extTable = isPlainTableIdentifier(e.table) ? e.table : derivedTable
           const alias = `ext_${sanitize(extName)}`
           q = q.leftJoin(`${extTable} as ${alias}` as any, (jb: any) =>
             jb.onRef(`${alias}.${e.join.extensionKey}`, '=', `${table}.${e.join.baseKey}`)

package/src/lib/ratelimit/service.ts

@@ -1,5 +1,5 @@
 import { RateLimiterMemory, RateLimiterRedis, RateLimiterRes } from 'rate-limiter-flexible'
-import { REDIS_WIRE_PROTOCOL } from '../redis/connection'
+import { parseRedisUrl } from '../redis/connection'
 import type { RateLimitConfig, RateLimitResult, RateLimitGlobalConfig } from './types'
 
 /** Narrow interface for the ioredis client — only the methods we actually use. */
@@ -22,10 +22,10 @@ export class RateLimiterService {
   async initialize(): Promise<void> {
     if (this.globalConfig.strategy === 'redis' && this.globalConfig.redisUrl) {
       const { default: Redis } = await import('ioredis')
-      this.redisClient = new Redis(this.globalConfig.redisUrl, {
+      this.redisClient = new Redis({
+        ...parseRedisUrl(this.globalConfig.redisUrl),
         enableOfflineQueue: false,
         maxRetriesPerRequest: 1,
-        protocol: REDIS_WIRE_PROTOCOL,
       })
     }
   }

package/src/modules/entities.ts

@@ -20,6 +20,21 @@ export type EntityExtension = {
     baseKey: string // column name on base (e.g., 'id')
     extensionKey: string // column name on extension (e.g., 'user_id')
   }
+  /**
+   * Physical table backing the extension entity.
+   *
+   * Optional. When omitted the query engine derives the table from the entity
+   * segment of `extension` with the same regular pluralizer it uses for every
+   * other table-name fallback, so `y` → `ies` is handled:
+   * `example:example_customer_priority` derives `example_customer_priorities`.
+   * Declare this for the plurals no guesser can win (`person` → `people`) and
+   * for any entity whose `@Entity({ tableName })` simply does not match the
+   * derived name.
+   *
+   * MUST be a plain identifier (`[A-Za-z_][A-Za-z0-9_]*`); the engine ignores
+   * any other value and falls back to the derived name.
+   */
+  table?: string
   cardinality?: 'one-to-one' | 'one-to-many' | 'many-to-one' | 'many-to-many'
   required?: boolean
   description?: string