@exvio/os-backend-core 0.4.0

package/src/guide/service.ts

@@ -0,0 +1,345 @@
+import { parseGuideMarkdown } from './markdown.ts'
+import { isGuideIdentifier } from './source.ts'
+import { GuideError } from './types.ts'
+import type {
+  GuideCatalogue,
+  GuideCatalogueCategory,
+  GuideCategory,
+  GuideContentSource,
+  GuideEntry,
+  GuideListItem,
+  GuideLoadInput,
+  GuideManifest,
+  GuidePolicy,
+  GuideService,
+  GuideServiceOptions,
+  GuideValidationResult,
+  LoadedGuide,
+  ParsedGuideMarkdown,
+} from './types.ts'
+
+export function createGuideService<
+  Locale extends string,
+  Context = unknown,
+  Entry extends GuideEntry<Locale> = GuideEntry<Locale>,
+  Category extends GuideCategory<Locale> = GuideCategory<Locale>,
+>(
+  options: GuideServiceOptions<Locale, Context, Entry, Category>,
+): GuideService<Locale, Context, Entry, Category> {
+  validateOptions(options)
+  const defaultLocale = options.defaultLocale
+  const listPolicy = options.listPolicy
+  const readPolicy = options.readPolicy
+  const source: GuideContentSource<Locale> = Object.freeze({
+    read: options.source.read.bind(options.source),
+  })
+  const locales = Object.freeze([...options.locales])
+  const localeSet = new Set<string>(locales)
+  const categories = Object.freeze(options.categories.map(category => snapshot(category))) as readonly Category[]
+  const entries = Object.freeze(options.entries.map(entry => snapshot(entry))) as readonly Entry[]
+  validateManifest(locales, defaultLocale, categories, entries)
+
+  const categoryIndex = new Map(categories.map((category, index) => [category.key, index]))
+  const entryIndex = new Map(entries.map((entry, index) => [entryKey(entry.category, entry.slug), index]))
+  const categoryByKey = new Map(categories.map(category => [category.key, category]))
+  const entryByKey = new Map(entries.map(entry => [entryKey(entry.category, entry.slug), entry]))
+  const manifest: GuideManifest<Locale, Entry, Category> = Object.freeze({
+    locales,
+    defaultLocale,
+    categories,
+    entries,
+  })
+
+  const readDocument = async (
+    entry: Entry,
+    requestedLocale: Locale,
+  ): Promise<{ parsed: ParsedGuideMarkdown; resolvedLocale: Locale } | null> => {
+    for (const resolvedLocale of fallbackLocales(entry, requestedLocale, defaultLocale)) {
+      const raw = await safeRead(source, {
+        category: entry.category,
+        slug: entry.slug,
+        locale: resolvedLocale,
+      })
+      if (raw !== null) return { parsed: parseGuideMarkdown(raw), resolvedLocale }
+    }
+    return null
+  }
+
+  const list = async (input: { readonly locale: Locale; readonly context?: Context }): Promise<
+    GuideCatalogue<Locale, Entry, Category>
+  > => {
+    validateLocaleInput(input, localeSet)
+    const requestedLocale = input.locale
+    const visible: GuideListItem<Locale, Entry>[] = []
+
+    for (const entry of sortEntries(entries, entryIndex)) {
+      if (!await applyPolicy(listPolicy, entry, input.context)) continue
+      const document = await readDocument(entry, requestedLocale)
+      if (!document) continue
+      visible.push(Object.freeze({
+        entry,
+        slug: entry.slug,
+        category: entry.category,
+        title: document.parsed.frontmatter.title || entry.slug,
+        description: document.parsed.frontmatter.description ?? '',
+        requestedLocale,
+        resolvedLocale: document.resolvedLocale,
+        availableLocales: entry.locales,
+      }))
+    }
+
+    const grouped: GuideCatalogueCategory<Locale, Entry, Category>[] = []
+    for (const category of sortCategories(categories, categoryIndex)) {
+      const items = Object.freeze(visible.filter(item => item.category === category.key))
+      if (items.length === 0) continue
+      grouped.push(Object.freeze({
+        category,
+        key: category.key,
+        title: localizedTitle(category, requestedLocale, defaultLocale, locales),
+        order: category.order,
+        items,
+      }))
+    }
+    return Object.freeze({ requestedLocale, categories: Object.freeze(grouped) })
+  }
+
+  const load = async (
+    input: GuideLoadInput<Locale, Context>,
+  ): Promise<LoadedGuide<Locale, Entry> | null> => {
+    validateLocaleInput(input, localeSet)
+    if (!isGuideIdentifier(input.category) || !isGuideIdentifier(input.slug)) invalidIdentifier()
+    const entry = entryByKey.get(entryKey(input.category, input.slug))
+    if (!entry || !await applyPolicy(readPolicy, entry, input.context)) return null
+    const document = await readDocument(entry, input.locale)
+    if (!document) return null
+    return Object.freeze({
+      entry,
+      frontmatter: document.parsed.frontmatter,
+      body: document.parsed.body,
+      requestedLocale: input.locale,
+      resolvedLocale: document.resolvedLocale,
+      availableLocales: entry.locales,
+    })
+  }
+
+  const validate = async (): Promise<GuideValidationResult> => {
+    let documentCount = 0
+    for (const entry of entries) {
+      for (const locale of entry.locales) {
+        const raw = await safeRead(source, {
+          category: entry.category,
+          slug: entry.slug,
+          locale,
+        })
+        if (raw === null) {
+          throw new GuideError({
+            code: 'document_not_found',
+            message: 'A guide document declared by the manifest is missing',
+          })
+        }
+        parseGuideMarkdown(raw)
+        documentCount += 1
+      }
+    }
+    return Object.freeze({
+      categoryCount: categoryByKey.size,
+      entryCount: entryByKey.size,
+      documentCount,
+    })
+  }
+
+  return Object.freeze({ manifest, list, load, validate })
+}
+
+function validateOptions<
+  Locale extends string,
+  Context,
+  Entry extends GuideEntry<Locale>,
+  Category extends GuideCategory<Locale>,
+>(options: GuideServiceOptions<Locale, Context, Entry, Category>): void {
+  if (!options || !Array.isArray(options.locales) || options.locales.length === 0
+    || !Array.isArray(options.categories) || options.categories.length === 0
+    || !Array.isArray(options.entries) || options.entries.length === 0
+    || !options.source || typeof options.source.read !== 'function') invalidManifest()
+}
+
+function validateManifest<Locale extends string>(
+  locales: readonly Locale[],
+  defaultLocale: Locale,
+  categories: readonly GuideCategory<Locale>[],
+  entries: readonly GuideEntry<Locale>[],
+): void {
+  if (new Set(locales).size !== locales.length || !locales.includes(defaultLocale)
+    || locales.some(locale => !isGuideIdentifier(locale))
+    || caseInsensitiveDuplicates(locales)) invalidManifest()
+  const categoryKeys = new Set<string>()
+  const foldedCategoryKeys = new Set<string>()
+  for (const category of categories) {
+    if (!category || !isGuideIdentifier(category.key) || categoryKeys.has(category.key)
+      || foldedCategoryKeys.has(category.key.toLocaleLowerCase('en-US'))
+      || !validOrder(category.order) || !category.title || typeof category.title !== 'object') invalidManifest()
+    categoryKeys.add(category.key)
+    foldedCategoryKeys.add(category.key.toLocaleLowerCase('en-US'))
+    if (Object.keys(category.title).some(locale => !locales.includes(locale as Locale))) invalidManifest()
+    for (const locale of locales) {
+      const value = category.title[locale]
+      if (value !== undefined && !nonEmpty(value)) invalidManifest()
+    }
+    if (!nonEmpty(category.title[defaultLocale])) invalidManifest()
+  }
+  const entryKeys = new Set<string>()
+  const foldedEntryKeys = new Set<string>()
+  for (const entry of entries) {
+    if (!entry || !isGuideIdentifier(entry.slug) || !isGuideIdentifier(entry.category)
+      || !categoryKeys.has(entry.category) || !validOrder(entry.order)
+      || !Array.isArray(entry.locales) || entry.locales.length === 0
+      || new Set(entry.locales).size !== entry.locales.length
+      || entry.locales.some(locale => !locales.includes(locale))) invalidManifest()
+    const key = entryKey(entry.category, entry.slug)
+    const foldedKey = entryKey(
+      entry.category.toLocaleLowerCase('en-US'),
+      entry.slug.toLocaleLowerCase('en-US'),
+    )
+    if (entryKeys.has(key) || foldedEntryKeys.has(foldedKey)) invalidManifest()
+    entryKeys.add(key)
+    foldedEntryKeys.add(foldedKey)
+  }
+}
+
+function fallbackLocales<Locale extends string>(
+  entry: GuideEntry<Locale>,
+  requested: Locale,
+  defaultLocale: Locale,
+): readonly Locale[] {
+  const result: Locale[] = []
+  const add = (locale: Locale): void => {
+    if (entry.locales.includes(locale) && !result.includes(locale)) result.push(locale)
+  }
+  add(requested)
+  add(defaultLocale)
+  for (const locale of entry.locales) add(locale)
+  return result
+}
+
+async function safeRead<Locale extends string>(
+  source: GuideContentSource<Locale>,
+  input: { readonly category: string; readonly slug: string; readonly locale: Locale },
+): Promise<string | null> {
+  let value: unknown
+  try {
+    value = await source.read(Object.freeze(input))
+  } catch (error) {
+    if (error instanceof GuideError && error.code === 'document_too_large') {
+      throw new GuideError({
+        code: 'document_too_large',
+        message: 'Guide document exceeds the size limit',
+      })
+    }
+    throw new GuideError({ code: 'source_failure', message: 'Guide content source failed' })
+  }
+  if (value !== null && typeof value !== 'string') {
+    throw new GuideError({ code: 'source_failure', message: 'Guide content source failed' })
+  }
+  return value
+}
+
+async function applyPolicy<Locale extends string, Context, Entry extends GuideEntry<Locale>>(
+  policy: GuidePolicy<Locale, Context, Entry> | undefined,
+  entry: Entry,
+  context: Context | undefined,
+): Promise<boolean> {
+  if (!policy) return true
+  try {
+    return await policy(entry, context) === true
+  } catch {
+    throw new GuideError({ code: 'policy_failure', message: 'Guide visibility policy failed' })
+  }
+}
+
+function validateLocaleInput<Locale extends string>(
+  input: { readonly locale: Locale } | null | undefined,
+  locales: ReadonlySet<string>,
+): asserts input is { readonly locale: Locale } {
+  if (!input || typeof input.locale !== 'string' || !locales.has(input.locale)) {
+    throw new GuideError({ code: 'invalid_locale', message: 'Guide locale is invalid' })
+  }
+}
+
+function localizedTitle<Locale extends string>(
+  category: GuideCategory<Locale>,
+  requested: Locale,
+  defaultLocale: Locale,
+  locales: readonly Locale[],
+): string {
+  const requestedTitle = category.title[requested]
+  if (nonEmpty(requestedTitle)) return requestedTitle
+  const fallback = category.title[defaultLocale]
+  if (nonEmpty(fallback)) return fallback
+  for (const locale of locales) {
+    const title = category.title[locale]
+    if (nonEmpty(title)) return title
+  }
+  invalidManifest()
+}
+
+function sortEntries<Locale extends string, Entry extends GuideEntry<Locale>>(
+  entries: readonly Entry[],
+  indices: ReadonlyMap<string, number>,
+): readonly Entry[] {
+  return [...entries].sort((left, right) => left.order - right.order
+    || (indices.get(entryKey(left.category, left.slug)) ?? 0)
+      - (indices.get(entryKey(right.category, right.slug)) ?? 0))
+}
+
+function sortCategories<Locale extends string, Category extends GuideCategory<Locale>>(
+  categories: readonly Category[],
+  indices: ReadonlyMap<string, number>,
+): readonly Category[] {
+  return [...categories].sort((left, right) => left.order - right.order
+    || (indices.get(left.key) ?? 0) - (indices.get(right.key) ?? 0))
+}
+
+function snapshot<Value>(value: Value, ancestors = new WeakSet<object>()): Value {
+  if (value === null || typeof value !== 'object') {
+    if (typeof value === 'function' || typeof value === 'symbol') invalidManifest()
+    return value
+  }
+  if (ancestors.has(value)) invalidManifest()
+  ancestors.add(value)
+  if (Array.isArray(value)) {
+    const result = Object.freeze(value.map(item => snapshot(item, ancestors))) as Value
+    ancestors.delete(value)
+    return result
+  }
+  const prototype = Object.getPrototypeOf(value) as unknown
+  if (prototype !== Object.prototype && prototype !== null) invalidManifest()
+  const result: Record<string, unknown> = Object.create(null) as Record<string, unknown>
+  for (const [key, item] of Object.entries(value)) result[key] = snapshot(item, ancestors)
+  ancestors.delete(value)
+  return Object.freeze(result) as Value
+}
+
+function validOrder(value: unknown): value is number {
+  return typeof value === 'number' && Number.isSafeInteger(value) && value >= 0
+}
+
+function nonEmpty(value: unknown): value is string {
+  return typeof value === 'string' && value.trim().length > 0
+}
+
+function caseInsensitiveDuplicates(values: readonly string[]): boolean {
+  const folded = values.map(value => value.toLocaleLowerCase('en-US'))
+  return new Set(folded).size !== folded.length
+}
+
+function entryKey(category: string, slug: string): string {
+  return `${category}\u0000${slug}`
+}
+
+function invalidIdentifier(): never {
+  throw new GuideError({ code: 'invalid_identifier', message: 'Guide identifier is invalid' })
+}
+
+function invalidManifest(): never {
+  throw new GuideError({ code: 'invalid_manifest', message: 'Guide manifest is invalid' })
+}

package/src/guide/source.ts

@@ -0,0 +1,116 @@
+import { open, realpath } from 'node:fs/promises'
+import path from 'node:path'
+import { GuideError } from './types.ts'
+import type {
+  FileGuideContentSourceOptions,
+  GuideContentRead,
+  GuideContentSource,
+} from './types.ts'
+
+const IDENTIFIER_PATTERN = /^[A-Za-z0-9]+(?:-[A-Za-z0-9]+)*$/
+const MAX_IDENTIFIER_LENGTH = 128
+const DEFAULT_MAX_FILE_BYTES = 1024 * 1024
+const MAX_FILE_BYTES = 16 * 1024 * 1024
+const READ_CHUNK_BYTES = 64 * 1024
+
+export function createFileGuideContentSource<Locale extends string>(
+  options: FileGuideContentSourceOptions,
+): GuideContentSource<Locale> {
+  if (!options || typeof options.root !== 'string' || !path.isAbsolute(options.root)) {
+    throw new GuideError({ code: 'invalid_source', message: 'Guide source root must be absolute' })
+  }
+  if (options.maxFileBytes !== undefined && (!Number.isSafeInteger(options.maxFileBytes)
+    || options.maxFileBytes <= 0 || options.maxFileBytes > MAX_FILE_BYTES)) {
+    throw new GuideError({ code: 'invalid_source', message: 'Guide source size limit is invalid' })
+  }
+  const configuredRoot = path.resolve(options.root)
+  const maxFileBytes = options.maxFileBytes ?? DEFAULT_MAX_FILE_BYTES
+  let realRootPromise: Promise<string> | undefined
+  const resolveRoot = (): Promise<string> => {
+    realRootPromise ??= realpath(configuredRoot).catch(() => { throw sourceFailure() })
+    return realRootPromise
+  }
+
+  return Object.freeze({
+    async read(input: GuideContentRead<Locale>): Promise<string | null> {
+      if (!input || !isGuideIdentifier(input.category) || !isGuideIdentifier(input.slug)
+        || !isGuideIdentifier(input.locale)) {
+        throw new GuideError({ code: 'invalid_identifier', message: 'Guide identifier is invalid' })
+      }
+      const root = await resolveRoot()
+      const candidate = path.resolve(configuredRoot, input.category, `${input.slug}.${input.locale}.md`)
+      if (!isContained(configuredRoot, candidate)) throw invalidIdentifier()
+
+      let actual: string
+      try {
+        actual = await realpath(candidate)
+      } catch (error) {
+        if (isMissingFile(error)) return null
+        throw sourceFailure()
+      }
+      if (!isContained(root, actual)) throw sourceFailure()
+      try {
+        return await readBounded(actual, maxFileBytes)
+      } catch (error) {
+        if (isMissingFile(error)) return null
+        if (error instanceof GuideError && error.code === 'document_too_large') throw error
+        throw sourceFailure()
+      }
+    },
+  })
+}
+
+async function readBounded(file: string, maxFileBytes: number): Promise<string> {
+  const handle = await open(file, 'r')
+  try {
+    const info = await handle.stat()
+    if (!info.isFile()) throw sourceFailure()
+    if (info.size > maxFileBytes) throw tooLarge()
+
+    const chunks: Buffer[] = []
+    let total = 0
+    for (;;) {
+      const remaining = maxFileBytes + 1 - total
+      if (remaining <= 0) throw tooLarge()
+      const buffer = Buffer.allocUnsafe(Math.min(READ_CHUNK_BYTES, remaining))
+      const { bytesRead } = await handle.read(buffer, 0, buffer.length, null)
+      if (bytesRead === 0) break
+      total += bytesRead
+      if (total > maxFileBytes) throw tooLarge()
+      chunks.push(buffer.subarray(0, bytesRead))
+    }
+    return Buffer.concat(chunks, total).toString('utf8')
+  } finally {
+    await handle.close().catch(() => undefined)
+  }
+}
+
+export function isGuideIdentifier(value: unknown): value is string {
+  return typeof value === 'string'
+    && value.length > 0
+    && value.length <= MAX_IDENTIFIER_LENGTH
+    && IDENTIFIER_PATTERN.test(value)
+}
+
+function isContained(root: string, candidate: string): boolean {
+  const relative = path.relative(root, candidate)
+  return relative === '' || (!relative.startsWith(`..${path.sep}`) && relative !== '..' && !path.isAbsolute(relative))
+}
+
+function isMissingFile(error: unknown): boolean {
+  if (!error || typeof error !== 'object' || !('code' in error)) return false
+  const code = (error as { code?: unknown }).code
+  return code === 'ENOENT' || code === 'ENOTDIR'
+}
+
+function invalidIdentifier(): GuideError {
+  return new GuideError({ code: 'invalid_identifier', message: 'Guide identifier is invalid' })
+}
+
+function sourceFailure(): GuideError {
+  return new GuideError({ code: 'source_failure', message: 'Guide content source failed' })
+}
+
+function tooLarge(): GuideError {
+  return new GuideError({ code: 'document_too_large', message: 'Guide document exceeds the size limit' })
+}

package/src/guide/types.ts

@@ -0,0 +1,177 @@
+export interface GuideCategory<Locale extends string> {
+  readonly key: string
+  readonly order: number
+  readonly title: Readonly<Partial<Record<Locale, string>>>
+}
+
+export interface GuideEntry<Locale extends string> {
+  readonly slug: string
+  readonly category: string
+  readonly order: number
+  readonly locales: readonly Locale[]
+}
+
+export interface GuideFrontmatter {
+  readonly title: string
+  readonly description?: string
+}
+
+export interface ParsedGuideMarkdown {
+  readonly frontmatter: GuideFrontmatter
+  readonly body: string
+}
+
+export interface GuideContentRead<Locale extends string> {
+  readonly category: string
+  readonly slug: string
+  readonly locale: Locale
+}
+
+export interface GuideContentSource<Locale extends string> {
+  /** Return null only when the document does not exist. */
+  read(input: GuideContentRead<Locale>): Promise<string | null>
+}
+
+export type GuidePolicy<Locale extends string, Context, Entry extends GuideEntry<Locale>> = (
+  entry: Entry,
+  context: Context | undefined,
+) => boolean | Promise<boolean>
+
+export interface GuideServiceOptions<
+  Locale extends string,
+  Context,
+  Entry extends GuideEntry<Locale>,
+  Category extends GuideCategory<Locale>,
+> {
+  readonly locales: readonly Locale[]
+  readonly defaultLocale: Locale
+  readonly categories: readonly Category[]
+  readonly entries: readonly Entry[]
+  readonly source: GuideContentSource<Locale>
+  /** Catalogue/UX visibility. It does not grant or deny detail access. */
+  readonly listPolicy?: GuidePolicy<Locale, Context, Entry>
+  /** Detail-read policy. Hidden/denied documents resolve to null. */
+  readonly readPolicy?: GuidePolicy<Locale, Context, Entry>
+}
+
+export interface GuideListInput<Locale extends string, Context> {
+  readonly locale: Locale
+  readonly context?: Context
+}
+
+export interface GuideLoadInput<Locale extends string, Context> {
+  readonly category: string
+  readonly slug: string
+  readonly locale: Locale
+  readonly context?: Context
+}
+
+export interface GuideListItem<Locale extends string, Entry extends GuideEntry<Locale>> {
+  readonly entry: Entry
+  readonly slug: string
+  readonly category: string
+  readonly title: string
+  readonly description: string
+  readonly requestedLocale: Locale
+  readonly resolvedLocale: Locale
+  readonly availableLocales: readonly Locale[]
+}
+
+export interface GuideCatalogueCategory<
+  Locale extends string,
+  Entry extends GuideEntry<Locale>,
+  Category extends GuideCategory<Locale>,
+> {
+  readonly category: Category
+  readonly key: string
+  readonly title: string
+  readonly order: number
+  readonly items: readonly GuideListItem<Locale, Entry>[]
+}
+
+export interface GuideCatalogue<
+  Locale extends string,
+  Entry extends GuideEntry<Locale>,
+  Category extends GuideCategory<Locale>,
+> {
+  readonly requestedLocale: Locale
+  readonly categories: readonly GuideCatalogueCategory<Locale, Entry, Category>[]
+}
+
+export interface LoadedGuide<Locale extends string, Entry extends GuideEntry<Locale>> {
+  readonly entry: Entry
+  readonly frontmatter: GuideFrontmatter
+  /** AI-only context comments are removed by default and cannot be requested raw. */
+  readonly body: string
+  readonly requestedLocale: Locale
+  readonly resolvedLocale: Locale
+  readonly availableLocales: readonly Locale[]
+}
+
+export interface GuideManifest<
+  Locale extends string,
+  Entry extends GuideEntry<Locale>,
+  Category extends GuideCategory<Locale>,
+> {
+  readonly locales: readonly Locale[]
+  readonly defaultLocale: Locale
+  readonly categories: readonly Category[]
+  readonly entries: readonly Entry[]
+}
+
+export interface GuideValidationResult {
+  readonly categoryCount: number
+  readonly entryCount: number
+  readonly documentCount: number
+}
+
+export interface GuideService<
+  Locale extends string,
+  Context,
+  Entry extends GuideEntry<Locale>,
+  Category extends GuideCategory<Locale>,
+> {
+  readonly manifest: GuideManifest<Locale, Entry, Category>
+  list(input: GuideListInput<Locale, Context>): Promise<GuideCatalogue<Locale, Entry, Category>>
+  load(input: GuideLoadInput<Locale, Context>): Promise<LoadedGuide<Locale, Entry> | null>
+  /** CI/startup audit of every document declared by the manifest. */
+  validate(): Promise<GuideValidationResult>
+}
+
+export type GuideErrorCode =
+  | 'invalid_manifest'
+  | 'invalid_identifier'
+  | 'invalid_locale'
+  | 'invalid_source'
+  | 'document_not_found'
+  | 'document_too_large'
+  | 'malformed_document'
+  | 'source_failure'
+  | 'policy_failure'
+
+export interface GuideErrorOptions {
+  readonly code: GuideErrorCode
+  readonly message: string
+}
+
+/** Stable error envelope; filesystem, policy, and parser causes are not retained. */
+export class GuideError extends Error {
+  readonly code: GuideErrorCode
+
+  constructor(options: GuideErrorOptions) {
+    super(options.message)
+    this.name = 'GuideError'
+    this.code = options.code
+  }
+}
+
+export interface FileGuideContentSourceOptions {
+  /**
+   * Must be an absolute, application-owned, read-only asset directory.
+   * Relative working directories are ambiguous after bundling, and this
+   * adapter is not a sandbox for concurrently attacker-writable content.
+   */
+  readonly root: string
+  /** Defaults to 1 MiB and is capped at 16 MiB. */
+  readonly maxFileBytes?: number
+}

package/src/index.ts

@@ -0,0 +1 @@
+export * from './tenant.ts'

package/src/tenant.ts

@@ -0,0 +1,14 @@
+export {
+  getCurrentTenant,
+  tenantContext,
+  withBypass,
+  withTenant,
+  type TenantStore,
+} from './db/tenant-context.ts'
+export { bypassTenant } from './db/bypass-tenant.ts'
+export { TenantFilterPlugin } from './db/plugins/tenant-filter.ts'
+export type {
+  MissingTenantContextPolicy,
+  TenantContextReader,
+  TenantFilterPluginOptions,
+} from './db/plugins/tenant-filter.ts'