katecms 0.0.0-stage → 1.0.0-beta.1

package/src/runtime/composables/getQueryCollection.ts

@@ -0,0 +1,325 @@
+import { computed } from 'vue'
+import { useAsyncData, useRequestFetch, useRoute } from '#imports'
+import { buildPublicPath } from '@katecms/core'
+import type { CollectionOrderField, DictionaryQuery, FieldsQuery } from '@katecms/core'
+import type { AdminEntry, QueryCollectionResponse } from '../utils/collections'
+import { isTruthyQueryParam, parsePublicStatusParam } from '../utils/preview'
+
+export type QueryCollectionOrderBy = CollectionOrderField | 'date' | 'modified' | 'name' | 'includeIds'
+export type QueryCollectionSlug = 'any' | (string & {})
+
+export interface GetQueryCollectionOptions {
+  /** Collection slug(s). `'any'` includes every public collection. */
+  collection: QueryCollectionSlug | QueryCollectionSlug[]
+  /**
+   * Include drafts when the requester may `collections:read` every queried
+   * collection. Also read from `?preview=1` on the current route.
+   */
+  preview?: boolean
+  /**
+   * Narrow statuses. `draft` is ignored unless preview is granted.
+   * Also read from `?status=` on the current route.
+   */
+  status?: 'published' | 'draft' | Array<'published' | 'draft'>
+  /** Listing page. Also read from `?page=` on the current route. */
+  page?: number
+  /**
+   * Page size. Also read from `?perPage=` on the current route.
+   * Default: the collection's `perPage` when a single type is queried,
+   * otherwise 10. `-1` returns every match.
+   */
+  perPage?: number
+  /** Title/slug search. */
+  search?: string
+  /** Exact title(s). */
+  title?: string | string[]
+  /** Only these entry ids. */
+  includeIds?: number | number[]
+  /** Skip these entry ids. */
+  excludeIds?: number | number[]
+  /** Parent id; `null` / `0` is top-level. */
+  parentId?: number | null
+  /** Entries whose parent id is in this list. `0` is top-level. */
+  parentIds?: number | number[]
+  /** Skip entries whose parent id is in this list. `0` is top-level. */
+  excludeParentIds?: number | number[]
+  /** Only these authors. */
+  authorIn?: number[]
+  /** Skip these authors. */
+  authorNotIn?: number[]
+  /** Entry slug(s). */
+  slug?: string | string[]
+  /** Entry slug(s). */
+  slugs?: string | string[]
+  /** Filter by dictionary rows (`relation` + `queries`). */
+  dictionaryQuery?: DictionaryQuery
+  /** Filter by entry `fields` JSON (`relation` + `queries`). */
+  fieldsQuery?: FieldsQuery
+  /** Sort field. `date` → `published_at`, `modified` → `updated_at`, `name` → `slug`, `includeIds` → `includeIds` order. */
+  orderBy?: QueryCollectionOrderBy
+  order?: 'asc' | 'desc'
+}
+
+function asList(value: string | string[] | number | number[] | undefined): string[] {
+  if (value == null) {
+    return []
+  }
+  const raw = Array.isArray(value) ? value : [value]
+  return [...new Set(raw.map(item => String(item).trim()).filter(Boolean))]
+}
+
+function csv(value: string | string[] | number | number[] | undefined): string | undefined {
+  const list = asList(value)
+  return list.length > 0 ? list.join(',') : undefined
+}
+
+function csvAll(
+  ...values: Array<string | string[] | number | number[] | undefined>
+): string | undefined {
+  const list = [...new Set(values.flatMap(value => asList(value)))]
+  return list.length > 0 ? list.join(',') : undefined
+}
+
+function parentIdToken(value: number | null | undefined): number | undefined {
+  if (value === undefined) {
+    return undefined
+  }
+  if (value == null || value === 0) {
+    return 0
+  }
+  return value
+}
+
+function parentIdsCsv(
+  parentId: number | null | undefined,
+  parentIds: number | number[] | undefined,
+): string | undefined {
+  const tokens: number[] = []
+  const seen = new Set<number>()
+  const push = (value: number | undefined) => {
+    if (value === undefined || seen.has(value)) {
+      return
+    }
+    seen.add(value)
+    tokens.push(value)
+  }
+  const list = parentIds == null
+    ? []
+    : Array.isArray(parentIds)
+      ? parentIds
+      : [parentIds]
+  for (const id of list) {
+    push(parentIdToken(id))
+  }
+  push(parentIdToken(parentId))
+  return tokens.length > 0 ? tokens.join(',') : undefined
+}
+
+function statusQueryValue(
+  status: GetQueryCollectionOptions['status'],
+): string | undefined {
+  if (!status) {
+    return undefined
+  }
+  return Array.isArray(status) ? status.join(',') : status
+}
+
+function pageQueryValue(
+  value: unknown,
+  fallback?: number,
+  allowUnlimited = false,
+): number | undefined {
+  if (
+    typeof fallback === 'number'
+    && Number.isInteger(fallback)
+    && (fallback >= 1 || (allowUnlimited && fallback === -1))
+  ) {
+    return fallback
+  }
+  const raw = Array.isArray(value) ? value[0] : value
+  const n = Number(raw)
+  if (allowUnlimited && n === -1) {
+    return -1
+  }
+  if (!Number.isInteger(n) || n < 1) {
+    return undefined
+  }
+  return n
+}
+
+/**
+ * List public collection entries by filters.
+ *
+ * Collections with `public: false` are omitted. Results stay published-only
+ * unless `preview` is set (option or `?preview=1`) and the visitor may read
+ * every queried collection.
+ *
+ * @example
+ * ```vue
+ * <script setup lang="ts">
+ * const { entries, permalink } = await getQueryCollection({
+ *   collection: 'any',
+ *   perPage: 10,
+ *   orderBy: 'date',
+ * })
+ * const mixed = await getQueryCollection({
+ *   collection: ['post', 'page'],
+ *   dictionaryQuery: {
+ *     relation: 'AND',
+ *     queries: [
+ *       { dictionary: 'services', field: 'slug', terms: 'theme-1' },
+ *       { dictionary: 'categories', operator: 'NOT IN', terms: 'category-1' },
+ *     ],
+ *   },
+ * })
+ * </script>
+ * ```
+ */
+export async function getQueryCollection(options: GetQueryCollectionOptions) {
+  const route = useRoute()
+  const collection = computed(() => asList(options.collection).join(','))
+  const preview = computed(() => options.preview ?? isTruthyQueryParam(route.query.preview))
+  const status = computed(() =>
+    statusQueryValue(options.status)
+    ?? ((parsePublicStatusParam(route.query.status) ?? []).join(',') || undefined),
+  )
+  const page = computed(() => pageQueryValue(route.query.page, options.page))
+  const perPage = computed(() => pageQueryValue(route.query.perPage, options.perPage, true))
+  const search = computed(() => options.search)
+  const title = computed(() => csv(options.title))
+  const includeIds = computed(() => csv(options.includeIds))
+  const excludeIds = computed(() => csv(options.excludeIds))
+  const parentIds = computed(() => parentIdsCsv(options.parentId, options.parentIds))
+  const excludeParentIds = computed(() => csv(options.excludeParentIds))
+  const authorIn = computed(() => csv(options.authorIn))
+  const authorNotIn = computed(() => csv(options.authorNotIn))
+  const slug = computed(() => csvAll(options.slugs, options.slug))
+  const dictionaryQuery = computed(() => (
+    options.dictionaryQuery
+      ? JSON.stringify(options.dictionaryQuery)
+      : undefined
+  ))
+  const fieldsQuery = computed(() => (
+    options.fieldsQuery
+      ? JSON.stringify(options.fieldsQuery)
+      : undefined
+  ))
+  const orderBy = computed(() => options.orderBy)
+  const order = computed(() => options.order)
+  const titleSet = computed(() => options.title !== undefined)
+  const includeIdsSet = computed(() => options.includeIds !== undefined)
+  const excludeIdsSet = computed(() => options.excludeIds !== undefined)
+  const parentIdsSet = computed(() =>
+    options.parentId !== undefined
+    || options.parentIds !== undefined,
+  )
+  const excludeParentIdsSet = computed(() => options.excludeParentIds !== undefined)
+  const authorInSet = computed(() => options.authorIn !== undefined)
+  const authorNotInSet = computed(() => options.authorNotIn !== undefined)
+  const slugSet = computed(() => options.slug !== undefined || options.slugs !== undefined)
+  const requestFetch = useRequestFetch()
+
+  const { data, pending, error, refresh } = await useAsyncData(
+    [
+      'katecms-query',
+      collection.value,
+      preview.value ? '1' : '0',
+      status.value ?? '',
+      page.value ?? '',
+      perPage.value ?? '',
+      search.value ?? '',
+      titleSet.value ? title.value ?? '' : '-',
+      includeIdsSet.value ? includeIds.value ?? '' : '-',
+      excludeIdsSet.value ? excludeIds.value ?? '' : '-',
+      parentIdsSet.value ? parentIds.value ?? '' : '-',
+      excludeParentIdsSet.value ? excludeParentIds.value ?? '' : '-',
+      authorInSet.value ? authorIn.value ?? '' : '-',
+      authorNotInSet.value ? authorNotIn.value ?? '' : '-',
+      slugSet.value ? slug.value ?? '' : '-',
+      dictionaryQuery.value ?? '',
+      fieldsQuery.value ?? '',
+      orderBy.value ?? '',
+      order.value ?? '',
+    ].join(':'),
+    () => requestFetch<QueryCollectionResponse>('/api/_katecms/query', {
+      query: {
+        collection: collection.value,
+        ...(preview.value ? { preview: '1' } : {}),
+        ...(status.value ? { status: status.value } : {}),
+        ...(page.value ? { page: page.value } : {}),
+        ...(perPage.value ? { perPage: perPage.value } : {}),
+        ...(search.value ? { search: search.value } : {}),
+        ...(titleSet.value ? { title: title.value ?? '' } : {}),
+        ...(includeIdsSet.value ? { includeIds: includeIds.value ?? '' } : {}),
+        ...(excludeIdsSet.value ? { excludeIds: excludeIds.value ?? '' } : {}),
+        ...(parentIdsSet.value ? { parentIds: parentIds.value ?? '' } : {}),
+        ...(excludeParentIdsSet.value ? { excludeParentIds: excludeParentIds.value ?? '' } : {}),
+        ...(authorInSet.value ? { authorIn: authorIn.value ?? '' } : {}),
+        ...(authorNotInSet.value ? { authorNotIn: authorNotIn.value ?? '' } : {}),
+        ...(slugSet.value ? { slug: slug.value ?? '' } : {}),
+        ...(dictionaryQuery.value ? { dictionaryQuery: dictionaryQuery.value } : {}),
+        ...(fieldsQuery.value ? { fieldsQuery: fieldsQuery.value } : {}),
+        ...(orderBy.value ? { orderBy: orderBy.value } : {}),
+        ...(order.value ? { order: order.value } : {}),
+      },
+    }),
+    {
+      watch: [
+        collection,
+        preview,
+        status,
+        page,
+        perPage,
+        search,
+        title,
+        titleSet,
+        includeIds,
+        includeIdsSet,
+        excludeIds,
+        excludeIdsSet,
+        parentIds,
+        parentIdsSet,
+        excludeParentIds,
+        excludeParentIdsSet,
+        authorIn,
+        authorInSet,
+        authorNotIn,
+        authorNotInSet,
+        slug,
+        slugSet,
+        dictionaryQuery,
+        fieldsQuery,
+        orderBy,
+        order,
+      ],
+    },
+  )
+
+  const entries = computed(() => data.value?.entries ?? [])
+  const collections = computed(() => data.value?.collections ?? [])
+  const isPreview = computed(() => data.value?.preview === true)
+  const queryPage = computed(() => data.value?.page ?? 1)
+  const queryPerPage = computed(() => data.value?.perPage ?? 0)
+  const total = computed(() => data.value?.total ?? 0)
+
+  function permalink(item: AdminEntry): string | null {
+    const meta = collections.value.find(entry => entry.slug === item.type)
+    if (!meta || !meta.public) {
+      return null
+    }
+    return buildPublicPath(meta.rewrite, meta.slug, item.slugPath || item.slug)
+  }
+
+  return {
+    entries,
+    collections,
+    permalink,
+    preview: isPreview,
+    page: queryPage,
+    perPage: queryPerPage,
+    total,
+    pending,
+    error,
+    refresh,
+  }
+}

package/src/runtime/composables/getTerms.ts

@@ -0,0 +1,231 @@
+import { computed } from 'vue'
+import { useAsyncData, useRequestFetch } from '#imports'
+import type { FieldsQuery, QueryTermsResult, TermOrderBy, TermOrderField, TermsReturn } from '@katecms/core'
+
+export interface GetTermsOptions {
+  /** Dictionary slug(s). */
+  dictionary: string | string[]
+  /**
+   * Page size. Omitted or `-1` returns every match.
+   */
+  perPage?: number
+  /** How many matches to skip. Default: `0`. */
+  offset?: number
+  /** Only these term ids. */
+  includeIds?: number | number[]
+  /** Skip these term ids. */
+  excludeIds?: number | number[]
+  /** Skip these terms and every descendant. */
+  excludeTreeIds?: number | number[]
+  /** Direct parent. `null` / `0` is top-level. */
+  parentId?: number | null
+  /** Every descendant of this term. The term itself is not included. */
+  childOf?: number
+  /** Skip terms that have children. Default: `false`. */
+  childless?: boolean
+  /** Exact slug(s). */
+  slug?: string | string[]
+  /** Exact title(s). */
+  title?: string | string[]
+  /** Case-insensitive substring of title or slug. */
+  search?: string
+  /** Hide terms with no published entries. Default: `true`. */
+  hideEmpty?: boolean
+  /**
+   * When `hideEmpty` is set, keep an empty term if a descendant has entries.
+   * Default: `true`.
+   */
+  hierarchical?: boolean
+  /** Add descendant entry counts to each term's `count`. Default: `false`. */
+  padCounts?: boolean
+  /** Filter term `fields`. */
+  fieldsQuery?: FieldsQuery
+  /** Default: `title`. */
+  orderBy?: TermOrderBy
+  /** Key used when `orderBy` is `field`. */
+  orderByField?: TermOrderField
+  /** Default: `asc`. */
+  order?: 'asc' | 'desc'
+  /**
+   * Shape of the result. `count` is the number of matches before `perPage`.
+   * Default: `all`.
+   */
+  return?: TermsReturn
+}
+
+function asList(value: string | string[] | number | number[] | undefined): string[] {
+  if (value == null) {
+    return []
+  }
+  const raw = Array.isArray(value) ? value : [value]
+  return [...new Set(raw.map(item => String(item).trim()).filter(Boolean))]
+}
+
+function csv(value: string | string[] | number | number[] | undefined): string | undefined {
+  const list = asList(value)
+  return list.length > 0 ? list.join(',') : undefined
+}
+
+function flag(value: boolean | undefined): string | undefined {
+  if (value === undefined) {
+    return undefined
+  }
+  return value ? '1' : '0'
+}
+
+/**
+ * List dictionary terms.
+ *
+ * `count` is the number of published entries in public collections.
+ * `hideEmpty` drops terms whose count is 0, unless `hierarchical` keeps a
+ * parent that has a non-empty descendant.
+ *
+ * @example
+ * ```vue
+ * <script setup lang="ts">
+ * const { terms } = await getTerms({
+ *   dictionary: 'services',
+ *   hideEmpty: true,
+ *   orderBy: 'title',
+ * })
+ * </script>
+ * ```
+ */
+export async function getTerms(options: GetTermsOptions) {
+  const dictionary = computed(() => asList(options.dictionary).join(','))
+  const perPage = computed(() => options.perPage)
+  const offset = computed(() => options.offset)
+  const includeIds = computed(() => csv(options.includeIds))
+  const excludeIds = computed(() => csv(options.excludeIds))
+  const excludeTreeIds = computed(() => csv(options.excludeTreeIds))
+  const parentId = computed(() => {
+    if (options.parentId === undefined) {
+      return undefined
+    }
+    if (options.parentId == null || options.parentId === 0) {
+      return '0'
+    }
+    return String(options.parentId)
+  })
+  const childOf = computed(() => (
+    options.childOf != null && options.childOf > 0 ? String(options.childOf) : undefined
+  ))
+  const childless = computed(() => flag(options.childless))
+  const slug = computed(() => csv(options.slug))
+  const title = computed(() => csv(options.title))
+  const search = computed(() => options.search)
+  const hideEmpty = computed(() => flag(options.hideEmpty))
+  const hierarchical = computed(() => flag(options.hierarchical))
+  const padCounts = computed(() => flag(options.padCounts))
+  const fieldsQuery = computed(() => (
+    options.fieldsQuery ? JSON.stringify(options.fieldsQuery) : undefined
+  ))
+  const orderBy = computed(() => options.orderBy)
+  const orderByField = computed(() => (
+    options.orderByField ? JSON.stringify(options.orderByField) : undefined
+  ))
+  const order = computed(() => options.order)
+  const returnMode = computed(() => options.return)
+  const includeIdsSet = computed(() => options.includeIds !== undefined)
+  const excludeIdsSet = computed(() => options.excludeIds !== undefined)
+  const excludeTreeIdsSet = computed(() => options.excludeTreeIds !== undefined)
+  const slugSet = computed(() => options.slug !== undefined)
+  const titleSet = computed(() => options.title !== undefined)
+  const requestFetch = useRequestFetch()
+
+  const { data, pending, error, refresh } = await useAsyncData(
+    [
+      'katecms-terms',
+      dictionary.value,
+      perPage.value ?? '',
+      offset.value ?? '',
+      includeIdsSet.value ? includeIds.value ?? '' : '-',
+      excludeIdsSet.value ? excludeIds.value ?? '' : '-',
+      excludeTreeIdsSet.value ? excludeTreeIds.value ?? '' : '-',
+      parentId.value ?? '-',
+      childOf.value ?? '',
+      childless.value ?? '',
+      slugSet.value ? slug.value ?? '' : '-',
+      titleSet.value ? title.value ?? '' : '-',
+      search.value ?? '',
+      hideEmpty.value ?? '',
+      hierarchical.value ?? '',
+      padCounts.value ?? '',
+      fieldsQuery.value ?? '',
+      orderBy.value ?? '',
+      orderByField.value ?? '',
+      order.value ?? '',
+      returnMode.value ?? '',
+    ].join(':'),
+    () => requestFetch<QueryTermsResult>('/api/_katecms/terms', {
+      query: {
+        dictionary: dictionary.value,
+        ...(perPage.value != null ? { perPage: perPage.value } : {}),
+        ...(offset.value != null ? { offset: offset.value } : {}),
+        ...(includeIdsSet.value ? { includeIds: includeIds.value ?? '' } : {}),
+        ...(excludeIdsSet.value ? { excludeIds: excludeIds.value ?? '' } : {}),
+        ...(excludeTreeIdsSet.value ? { excludeTreeIds: excludeTreeIds.value ?? '' } : {}),
+        ...(parentId.value != null ? { parentId: parentId.value } : {}),
+        ...(childOf.value ? { childOf: childOf.value } : {}),
+        ...(childless.value != null ? { childless: childless.value } : {}),
+        ...(slugSet.value ? { slug: slug.value ?? '' } : {}),
+        ...(titleSet.value ? { title: title.value ?? '' } : {}),
+        ...(search.value ? { search: search.value } : {}),
+        ...(hideEmpty.value != null ? { hideEmpty: hideEmpty.value } : {}),
+        ...(hierarchical.value != null ? { hierarchical: hierarchical.value } : {}),
+        ...(padCounts.value != null ? { padCounts: padCounts.value } : {}),
+        ...(fieldsQuery.value ? { fieldsQuery: fieldsQuery.value } : {}),
+        ...(orderBy.value ? { orderBy: orderBy.value } : {}),
+        ...(orderByField.value ? { orderByField: orderByField.value } : {}),
+        ...(order.value ? { order: order.value } : {}),
+        ...(returnMode.value ? { return: returnMode.value } : {}),
+      },
+    }),
+    {
+      watch: [
+        dictionary,
+        perPage,
+        offset,
+        includeIds,
+        includeIdsSet,
+        excludeIds,
+        excludeIdsSet,
+        excludeTreeIds,
+        excludeTreeIdsSet,
+        parentId,
+        childOf,
+        childless,
+        slug,
+        slugSet,
+        title,
+        titleSet,
+        search,
+        hideEmpty,
+        hierarchical,
+        padCounts,
+        fieldsQuery,
+        orderBy,
+        orderByField,
+        order,
+        returnMode,
+      ],
+    },
+  )
+
+  const terms = computed(() => data.value?.terms ?? [])
+  const ids = computed(() => data.value?.ids ?? [])
+  const titles = computed(() => data.value?.titles ?? [])
+  const map = computed(() => data.value?.map ?? {})
+  const total = computed(() => data.value?.total ?? 0)
+
+  return {
+    terms,
+    ids,
+    titles,
+    map,
+    total,
+    pending,
+    error,
+    refresh,
+  }
+}

package/src/runtime/composables/useAuth.ts

@@ -0,0 +1,43 @@
+import { computed, ref } from 'vue'
+import { $fetch, navigateTo, useFetch } from '#imports'
+import type { AuthState, SafeUser } from '@katecms/core'
+import { useCmsPaths } from './useCmsPaths'
+
+/**
+ * Shared auth snapshot for admin UI (header profile, logout, etc.).
+ * Uses a stable fetch key so multiple consumers share one request.
+ */
+export function useAuth() {
+  const paths = useCmsPaths()
+  const { data, refresh, pending, error, clear } = useFetch<AuthState>('/api/_katecms/auth/state', {
+    key: 'katecms-auth-state',
+  })
+
+  const user = computed<SafeUser | null>(() => data.value?.user ?? null)
+  const loggingOut = ref(false)
+
+  async function logout() {
+    if (loggingOut.value) {
+      return
+    }
+    loggingOut.value = true
+    try {
+      await $fetch('/api/_katecms/auth/logout', { method: 'POST' })
+      clear()
+      await navigateTo(paths.login)
+    }
+    finally {
+      loggingOut.value = false
+    }
+  }
+
+  return {
+    user,
+    authState: data,
+    refresh,
+    pending,
+    error,
+    loggingOut,
+    logout,
+  }
+}

package/src/runtime/composables/useAuthCooldown.ts

@@ -0,0 +1,52 @@
+import { computed, onUnmounted, ref } from 'vue'
+
+/** Client-side wait after the server reports `retryAfterMs` on a failed auth attempt. */
+export function useAuthCooldown() {
+  const cooldownUntil = ref(0)
+  const now = ref(Date.now())
+  let timer: ReturnType<typeof setInterval> | undefined
+  let onUnlock: (() => void) | undefined
+
+  const remainingMs = computed(() => Math.max(0, cooldownUntil.value - now.value))
+  const remainingSec = computed(() => Math.ceil(remainingMs.value / 1000))
+  const locked = computed(() => remainingMs.value > 0)
+
+  function finish() {
+    if (!timer) {
+      return
+    }
+    clearInterval(timer)
+    timer = undefined
+    const done = onUnlock
+    onUnlock = undefined
+    done?.()
+  }
+
+  function tick() {
+    now.value = Date.now()
+    if (remainingMs.value <= 0) {
+      finish()
+    }
+  }
+
+  function start(retryAfterMs: number, unlock?: () => void) {
+    if (retryAfterMs <= 0) {
+      return
+    }
+    onUnlock = unlock
+    cooldownUntil.value = Date.now() + retryAfterMs
+    now.value = Date.now()
+    if (!timer) {
+      timer = setInterval(tick, 250)
+    }
+  }
+
+  onUnmounted(() => {
+    if (timer) {
+      clearInterval(timer)
+      timer = undefined
+    }
+  })
+
+  return { remainingSec, locked, start }
+}

package/src/runtime/composables/useCmsPaths.ts

@@ -0,0 +1,24 @@
+import { useRuntimeConfig } from '#imports'
+import { cmsAdminChildPath, cmsRoutePath } from '../utils/cms-paths'
+
+export function useCmsPaths() {
+  const config = useRuntimeConfig().public.katecms
+  const admin = cmsRoutePath(config?.adminPath || 'admin')
+  return {
+    admin,
+    media: `${admin}/media`,
+    users: `${admin}/users`,
+    user: (id: number | string) => `${admin}/users/${id}`,
+    demoFields: `${admin}/demo-fields`,
+    collection: (slug: string) => `${admin}/collections/${encodeURIComponent(slug)}`,
+    collectionCreate: (slug: string) => `${admin}/collections/${encodeURIComponent(slug)}/create`,
+    collectionEntry: (slug: string, id: number | string) =>
+      `${admin}/collections/${encodeURIComponent(slug)}/${id}`,
+    dictionary: (slug: string) => `${admin}/dictionaries/${encodeURIComponent(slug)}`,
+    dictionaryTerm: (slug: string, id: number | string) =>
+      `${admin}/dictionaries/${encodeURIComponent(slug)}/${id}`,
+    option: (slug: string) => `${admin}/options/${encodeURIComponent(slug)}`,
+    login: cmsAdminChildPath(config?.adminPath || 'admin', config?.loginPath || 'login'),
+    register: cmsAdminChildPath(config?.adminPath || 'admin', config?.registerPath || 'register'),
+  }
+}