@byline/host-tanstack-start 4.16.0 → 4.18.0

package/src/routes/create-collection-list-route.tsx

@@ -10,12 +10,8 @@ import { useEffect, useRef } from 'react'
 import { createFileRoute, notFound } from '@tanstack/react-router'
 
 import { applyRelationColumnFormatters } from '@byline/admin/react'
-import type { CollectionDefinition } from '@byline/core'
-import {
-  getCollectionAdminConfig,
-  getCollectionDefinition,
-  getWorkflowStatuses,
-} from '@byline/core'
+import type { MultiCollectionDefinition } from '@byline/core'
+import { getCollectionAdminConfig, getWorkflowStatuses } from '@byline/core'
 import { useTranslation } from '@byline/i18n/react'
 import { useToastManager } from '@byline/ui/react'
 import type { z } from 'zod'
@@ -31,6 +27,7 @@ import {
   reorderCollectionDocument,
 } from '../server-fns/collections/index.js'
 import { getAdminRoutePath } from './admin-path.js'
+import { getMultiCollectionDefinition } from './get-multi-collection-definition.js'
 import { collectionListSearchSchema as searchSchema } from './list-return-state.js'
 import type { CollectionTreeRow } from '../server-fns/collections/tree.js'
 
@@ -62,7 +59,7 @@ export function createCollectionListRoute(path: string) {
         status?: string
       }
     }) => {
-      const collectionDef = getCollectionDefinition(params.collection)
+      const collectionDef = getMultiCollectionDefinition(params.collection)
       if (!collectionDef) {
         throw notFound()
       }
@@ -108,7 +105,7 @@ export function createCollectionListRoute(path: string) {
       const { collection } = Route.useParams() as { collection: string }
       const search = Route.useSearch() as z.infer<typeof searchSchema>
       const navigate = useNavigate()
-      const collectionDef = getCollectionDefinition(collection) as CollectionDefinition
+      const collectionDef = getMultiCollectionDefinition(collection) as MultiCollectionDefinition
       const adminConfig = getCollectionAdminConfig(collection)
       // Apply the built-in relation formatter to any relation column without an
       // explicit one, so relation cells render the target's title (the list

package/src/routes/create-singleton-history-route.test.node.ts

@@ -0,0 +1,148 @@
+/**
+ * This Source Code is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * Copyright (c) Infonomic Company Limited
+ */
+
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+const mocks = vi.hoisted(() => ({
+  getSingletonHistory: vi.fn(),
+  getSingleton: vi.fn(),
+  definition: {
+    singleton: true,
+    path: 'site-settings',
+    label: 'Site settings',
+    fields: [],
+  },
+}))
+
+vi.mock('@tanstack/react-router', () => ({
+  createFileRoute: () => (options: Record<string, unknown>) => ({ options }),
+  notFound: () => new Error('not found'),
+}))
+
+vi.mock('@byline/core', () => ({
+  getCollectionDefinition: (path: string) =>
+    path === mocks.definition.path ? mocks.definition : null,
+  isSingleton: (definition: { singleton?: boolean }) => definition.singleton === true,
+  getSingletonAdminConfig: () => null,
+  getWorkflowStatuses: () => [],
+}))
+
+vi.mock('../server-fns/singletons/index.js', () => ({
+  getSingletonHistory: mocks.getSingletonHistory,
+  getSingleton: mocks.getSingleton,
+}))
+
+vi.mock('../admin-shell/chrome/breadcrumbs/breadcrumbs-client.js', () => ({
+  BreadcrumbsClient: () => null,
+}))
+vi.mock('../admin-shell/singletons/history.js', () => ({ SingletonHistoryView: () => null }))
+vi.mock('@byline/i18n/react', () => ({ useTranslation: () => ({ t: (key: string) => key }) }))
+vi.mock('./admin-path.js', () => ({ getAdminRoutePath: () => '/admin' }))
+vi.mock('./get-content-locale-route-config.js', () => ({
+  getContentLocaleRouteConfig: () => ({ contentLocales: [], defaultContentLocale: 'en' }),
+}))
+
+import { createSingletonHistoryRoute } from './create-singleton-history-route.js'
+
+interface RouteLoaderInput {
+  params: { singleton: string }
+  deps: {
+    page?: number
+    page_size?: number
+    order?: string
+    desc?: boolean
+    locale?: string
+  }
+}
+
+type RouteLoader = (input: RouteLoaderInput) => Promise<unknown>
+
+function loader(): RouteLoader {
+  const route = createSingletonHistoryRoute('/admin/singletons/$singleton/history') as {
+    options: { loader: RouteLoader }
+  }
+  return route.options.loader
+}
+
+describe('singleton history route loader', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    mocks.getSingleton.mockResolvedValue(null)
+  })
+
+  it('loads a paginated materialised singleton history without a document id input', async () => {
+    const history = {
+      docs: [{ id: 'document-settings', versionId: 'version-1', status: 'draft' }],
+      meta: { total: 3, page: 2, pageSize: 1, totalPages: 3 },
+      actors: {},
+    }
+    const currentDocument = {
+      id: 'document-settings',
+      versionId: 'version-3',
+      status: 'draft',
+      fields: {},
+    }
+    mocks.getSingletonHistory.mockResolvedValue(history)
+    mocks.getSingleton.mockResolvedValue(currentDocument)
+
+    await expect(
+      loader()({
+        params: { singleton: 'site-settings' },
+        deps: { page: 2, page_size: 1, order: 'created_at', desc: true, locale: 'fr' },
+      })
+    ).resolves.toEqual({ history, currentDocument })
+
+    expect(mocks.getSingletonHistory).toHaveBeenCalledWith({
+      data: {
+        singleton: 'site-settings',
+        params: {
+          page: 2,
+          page_size: 1,
+          order: 'created_at',
+          desc: true,
+          locale: 'fr',
+        },
+      },
+    })
+    expect(mocks.getSingleton).toHaveBeenCalledWith({
+      data: { singleton: 'site-settings', locale: 'fr' },
+    })
+  })
+
+  it('preserves the requested empty FindResult envelope for an unmaterialised slot', async () => {
+    const history = {
+      docs: [],
+      meta: { total: 0, page: 4, pageSize: 30, totalPages: 0 },
+      actors: {},
+    }
+    mocks.getSingletonHistory.mockResolvedValue(history)
+
+    await expect(
+      loader()({
+        params: { singleton: 'site-settings' },
+        deps: { page: 4, page_size: 30 },
+      })
+    ).resolves.toEqual({ history, currentDocument: null })
+
+    expect(mocks.getSingleton).toHaveBeenCalledWith({
+      data: { singleton: 'site-settings', locale: 'all' },
+    })
+  })
+
+  it('preserves a kind-aware read denial from the singleton handle', async () => {
+    const forbidden = {
+      code: 'ERR_FORBIDDEN',
+      details: { ability: 'singletons.site-settings.read' },
+    }
+    mocks.getSingletonHistory.mockRejectedValue(forbidden)
+
+    await expect(loader()({ params: { singleton: 'site-settings' }, deps: {} })).rejects.toBe(
+      forbidden
+    )
+  })
+})

package/src/routes/create-singleton-history-route.tsx

@@ -0,0 +1,116 @@
+/**
+ * This Source Code is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * Copyright (c) Infonomic Company Limited
+ */
+
+import { createFileRoute, notFound } from '@tanstack/react-router'
+
+import { getSingletonAdminConfig, getWorkflowStatuses } from '@byline/core'
+import { useTranslation } from '@byline/i18n/react'
+import { z } from 'zod'
+
+import { BreadcrumbsClient } from '../admin-shell/chrome/breadcrumbs/breadcrumbs-client.js'
+import { SingletonHistoryView } from '../admin-shell/singletons/history.js'
+import { getSingleton, getSingletonHistory } from '../server-fns/singletons/index.js'
+import { getAdminRoutePath } from './admin-path.js'
+import { getContentLocaleRouteConfig } from './get-content-locale-route-config.js'
+import { getSingletonDefinition } from './get-singleton-definition.js'
+import type { VersionHistoryData } from '../admin-shell/collections/version-history.js'
+
+const searchSchema = z.object({
+  page: z.coerce.number().min(1).optional(),
+  page_size: z.coerce.number().max(100).optional(),
+  order: z.string().optional(),
+  desc: z.coerce.boolean().optional(),
+  locale: z.string().optional(),
+})
+
+export function createSingletonHistoryRoute(path: string) {
+  // biome-ignore lint/suspicious/noExplicitAny: dynamic path bypasses route-tree typing
+  const Route: any = createFileRoute(path as never)({
+    validateSearch: searchSchema,
+    loaderDeps: ({ search }: { search: z.infer<typeof searchSchema> }) => ({
+      page: search.page,
+      page_size: search.page_size,
+      order: search.order,
+      desc: search.desc,
+      locale: search.locale,
+    }),
+    loader: async ({
+      params,
+      deps,
+    }: {
+      params: { singleton: string }
+      deps: z.infer<typeof searchSchema>
+    }) => {
+      if (getSingletonDefinition(params.singleton) == null) throw notFound()
+
+      const [history, currentDocument] = await Promise.all([
+        getSingletonHistory({
+          data: {
+            singleton: params.singleton,
+            params: {
+              page: deps.page,
+              page_size: deps.page_size,
+              order: deps.order,
+              desc: deps.desc,
+              locale: deps.locale,
+            },
+          },
+        }),
+        // Use the same locale shape as the version stream so DiffModal compares
+        // like with like. An empty slot returns null while history returns its
+        // requested empty FindResult envelope.
+        getSingleton({
+          data: { singleton: params.singleton, locale: deps.locale ?? 'all' },
+        }),
+      ])
+
+      return { history, currentDocument }
+    },
+    staleTime: 0,
+    gcTime: 0,
+    shouldReload: true,
+    component: function SingletonHistoryRouteComponent() {
+      const { history, currentDocument } = Route.useLoaderData()
+      const { singleton } = Route.useParams() as { singleton: string }
+      const definition = getSingletonDefinition(singleton)
+      if (definition == null) throw notFound()
+
+      const { t } = useTranslation('byline-admin')
+      const { contentLocales, defaultContentLocale } = getContentLocaleRouteConfig()
+
+      return (
+        <>
+          <BreadcrumbsClient
+            breadcrumbs={[
+              { label: t('chrome.menu.dashboard'), href: getAdminRoutePath() },
+              {
+                label: definition.label,
+                href: getAdminRoutePath('singletons', singleton),
+              },
+              {
+                label: t('collections.breadcrumbs.history'),
+                href: getAdminRoutePath('singletons', singleton, 'history'),
+              },
+            ]}
+          />
+          <SingletonHistoryView
+            singletonDefinition={definition}
+            adminConfig={getSingletonAdminConfig(singleton) ?? undefined}
+            data={history as VersionHistoryData}
+            currentDocument={currentDocument as Record<string, unknown> | null}
+            contentLocales={contentLocales}
+            defaultContentLocale={defaultContentLocale}
+            workflowStatuses={getWorkflowStatuses(definition)}
+          />
+        </>
+      )
+    },
+  })
+
+  return Route
+}

package/src/routes/create-singleton-route.test.node.ts

@@ -0,0 +1,172 @@
+/**
+ * This Source Code is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * Copyright (c) Infonomic Company Limited
+ */
+
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+const mocks = vi.hoisted(() => ({
+  definition: {
+    singleton: true,
+    path: 'site-settings',
+    label: 'Site settings',
+    fields: [{ name: 'title', type: 'text', defaultValue: 'Default title' }],
+  },
+  read: vi.fn(),
+  buildInitialData: vi.fn(),
+  getPublishedVersion: vi.fn(),
+  getRequestContext: vi.fn(),
+  getScheduledPublish: vi.fn(),
+  getCollectionRecord: vi.fn(),
+  scheduledPublicationEnabled: true,
+}))
+
+vi.mock('@tanstack/react-start', () => ({
+  createServerFn: () => {
+    let validate = (input: unknown) => input
+    const chain = {
+      validator(validator: (input: unknown) => unknown) {
+        validate = validator
+        return chain
+      },
+      handler(handler: (options: { data: any }) => Promise<unknown>) {
+        return async (options: { data: unknown }) => handler({ data: validate(options.data) })
+      },
+    }
+    return chain
+  },
+}))
+
+vi.mock('@tanstack/react-router', () => ({
+  createFileRoute: () => (options: Record<string, unknown>) => ({ options }),
+  notFound: () => new Error('not found'),
+}))
+
+vi.mock('@byline/client/server', () => ({
+  getAdminBylineClient: () => ({
+    singleton: () => ({ getScheduledPublish: mocks.getScheduledPublish }),
+  }),
+  getAdminRequestContext: mocks.getRequestContext,
+}))
+
+vi.mock('@byline/core', () => ({
+  buildInitialDataFromFields: mocks.buildInitialData,
+  documentAbilityKey: (_definition: unknown, verb: string) => `singletons.site-settings.${verb}`,
+  getCollectionDefinition: (path: string) =>
+    path === mocks.definition.path ? mocks.definition : null,
+  isSingleton: (definition: { singleton?: boolean }) => definition.singleton === true,
+  getServerConfig: () => ({
+    i18n: { content: { defaultLocale: 'en' } },
+    scheduledPublication: { enabled: mocks.scheduledPublicationEnabled },
+    db: { queries: { documents: { getPublishedVersion: mocks.getPublishedVersion } } },
+  }),
+  getSingletonAdminConfig: () => null,
+}))
+
+vi.mock('../admin-shell/chrome/breadcrumbs/breadcrumbs-client.js', () => ({
+  BreadcrumbsClient: () => null,
+}))
+vi.mock('../admin-shell/singletons/view.js', () => ({ SingletonView: () => null }))
+vi.mock('../integrations/byline-core.js', () => ({
+  bylineCore: () => ({ getCollectionRecord: mocks.getCollectionRecord }),
+}))
+vi.mock('../server-fns/singleton-document-read.js', () => ({
+  readSingletonDocument: mocks.read,
+}))
+vi.mock('../server-fns/serialise.js', () => ({ serialise: (value: unknown) => value }))
+vi.mock('@byline/i18n/react', () => ({ useTranslation: () => ({ t: (key: string) => key }) }))
+vi.mock('./admin-path.js', () => ({ getAdminRoutePath: () => '/admin' }))
+vi.mock('./get-content-locale-route-config.js', () => ({
+  getContentLocaleRouteConfig: () => ({ contentLocales: [], defaultContentLocale: 'en' }),
+}))
+
+import { getSingletonRouteDocument } from './create-singleton-route.js'
+
+type ServerFunction = (options: { data: { singleton: string; locale?: string } }) => Promise<any>
+
+const load = (locale?: string) =>
+  (getSingletonRouteDocument as ServerFunction)({
+    data: { singleton: 'site-settings', locale },
+  })
+
+describe('singleton editor route loader', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    mocks.scheduledPublicationEnabled = true
+    mocks.buildInitialData.mockResolvedValue({ title: 'Default title' })
+    mocks.getCollectionRecord.mockReturnValue({ collectionId: 'collection-settings' })
+    mocks.getRequestContext.mockResolvedValue({
+      actor: {
+        hasAbility: (ability: string) =>
+          ability === 'singletons.site-settings.changeStatus' ||
+          ability === 'singletons.site-settings.publish',
+      },
+    })
+  })
+
+  it('resolves schema defaults without inventing a document for an empty slot', async () => {
+    mocks.read.mockResolvedValue(null)
+
+    await expect(load('fr')).resolves.toEqual({
+      document: null,
+      initialData: { title: 'Default title' },
+    })
+    expect(mocks.read).toHaveBeenCalledWith({
+      singleton: 'site-settings',
+      locale: 'fr',
+      populateRelations: true,
+    })
+    expect(mocks.buildInitialData).toHaveBeenCalledWith(mocks.definition.fields, { locale: 'fr' })
+    expect(mocks.getCollectionRecord).not.toHaveBeenCalled()
+    expect(mocks.getRequestContext).not.toHaveBeenCalled()
+  })
+
+  it('attaches publication and schedule metadata to a mapped document server-side', async () => {
+    mocks.read.mockResolvedValue({
+      id: 'document-settings',
+      versionId: 'version-current',
+      status: 'draft',
+      fields: { title: 'Loaded' },
+    })
+    mocks.getPublishedVersion.mockResolvedValue({
+      document_id: 'document-settings',
+      document_version_id: 'version-published',
+      status: 'published',
+      created_at: '2026-08-25T00:00:00.000Z',
+      updated_at: '2026-08-25T01:00:00.000Z',
+    })
+    mocks.getScheduledPublish.mockResolvedValue({
+      state: 'armed',
+      publishAt: '2026-09-01T00:00:00.000Z',
+      targetVersionId: 'version-current',
+    })
+
+    const result = await load()
+
+    expect(result.initialData).toBeUndefined()
+    expect(result.document).toMatchObject({
+      id: 'document-settings',
+      _publishedVersion: {
+        id: 'document-settings',
+        versionId: 'version-published',
+        status: 'published',
+      },
+      _scheduledPublicationEnabled: true,
+      _canSchedulePublication: true,
+      _scheduledPublish: {
+        state: 'armed',
+        targetVersionId: 'version-current',
+      },
+      scheduledPublishAt: '2026-09-01T00:00:00.000Z',
+      scheduledPublishVersionId: 'version-current',
+    })
+    expect(mocks.getPublishedVersion).toHaveBeenCalledWith({
+      collection_id: 'collection-settings',
+      document_id: 'document-settings',
+    })
+    expect(mocks.getScheduledPublish).toHaveBeenCalledTimes(1)
+  })
+})

package/src/routes/create-singleton-route.tsx

@@ -0,0 +1,176 @@
+/**
+ * This Source Code is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * Copyright (c) Infonomic Company Limited
+ */
+
+import { createFileRoute, notFound } from '@tanstack/react-router'
+import { createServerFn } from '@tanstack/react-start'
+
+import type { DocumentPublishScheduleInfo } from '@byline/client'
+import { getAdminBylineClient, getAdminRequestContext } from '@byline/client/server'
+import {
+  buildInitialDataFromFields,
+  documentAbilityKey,
+  getServerConfig,
+  getSingletonAdminConfig,
+} from '@byline/core'
+import { useTranslation } from '@byline/i18n/react'
+import { z } from 'zod'
+
+import { BreadcrumbsClient } from '../admin-shell/chrome/breadcrumbs/breadcrumbs-client.js'
+import { SingletonView } from '../admin-shell/singletons/view.js'
+import { bylineCore } from '../integrations/byline-core.js'
+import { serialise } from '../server-fns/serialise.js'
+import { readSingletonDocument } from '../server-fns/singleton-document-read.js'
+import { getAdminRoutePath } from './admin-path.js'
+import { getContentLocaleRouteConfig } from './get-content-locale-route-config.js'
+import { getSingletonDefinition } from './get-singleton-definition.js'
+
+const searchSchema = z.object({ locale: z.string().optional() })
+
+/**
+ * Load the mapped singleton document and attach the admin-only lifecycle
+ * metadata consumed by the editor. Keeping this composition in the route
+ * layer leaves ordinary singleton reads free of publication timing and actor
+ * capability details.
+ */
+export const getSingletonRouteDocument = createServerFn({ method: 'GET' })
+  .validator((input: { singleton: string; locale?: string }) => input)
+  .handler(async ({ data }) => {
+    const definition = getSingletonDefinition(data.singleton)
+    if (definition == null) return null
+
+    const document = await readSingletonDocument({
+      singleton: data.singleton,
+      locale: data.locale,
+      populateRelations: true,
+    })
+    if (document == null) {
+      return {
+        document: null,
+        initialData: serialise(
+          await buildInitialDataFromFields(definition.fields, {
+            locale: data.locale ?? getServerConfig().i18n.content.defaultLocale,
+          })
+        ),
+      }
+    }
+
+    const config = getServerConfig()
+    const record = bylineCore().getCollectionRecord(data.singleton)
+
+    // A current draft may coexist with an older published version. That fact
+    // is editorial metadata, so it is intentionally attached only here rather
+    // than to every singleton read.
+    let publishedVersion: Record<string, any> | null = null
+    if ((document as Record<string, unknown>).status !== 'published') {
+      const published = await config.db.queries.documents.getPublishedVersion({
+        collection_id: record.collectionId,
+        document_id: String((document as Record<string, unknown>).id),
+      })
+      publishedVersion = published
+        ? serialise({
+            id: published.document_id,
+            versionId: published.document_version_id,
+            status: published.status,
+            createdAt: published.created_at,
+            updatedAt: published.updated_at,
+          })
+        : null
+    }
+
+    // Scheduling metadata is revealed only when the feature is enabled and
+    // the authenticated actor holds both abilities needed to arm a publish.
+    const scheduledPublicationEnabled = config.scheduledPublication?.enabled === true
+    let canSchedulePublication = false
+    let scheduledPublish: DocumentPublishScheduleInfo | null = null
+    if (scheduledPublicationEnabled) {
+      const actor = (await getAdminRequestContext()).actor
+      canSchedulePublication =
+        actor?.hasAbility(documentAbilityKey(definition, 'changeStatus')) === true &&
+        actor.hasAbility(documentAbilityKey(definition, 'publish'))
+      if (canSchedulePublication) {
+        scheduledPublish = await getAdminBylineClient()
+          .singleton(data.singleton)
+          .getScheduledPublish()
+      }
+    }
+    const serializedSchedule = scheduledPublish == null ? null : serialise(scheduledPublish)
+
+    return {
+      document: {
+        ...(document as Record<string, unknown>),
+        _publishedVersion: publishedVersion,
+        _scheduledPublicationEnabled: scheduledPublicationEnabled,
+        _canSchedulePublication: canSchedulePublication,
+        _scheduledPublish: serializedSchedule,
+        ...(serializedSchedule == null
+          ? {}
+          : {
+              scheduledPublishAt: serializedSchedule.publishAt,
+              scheduledPublishVersionId: serializedSchedule.targetVersionId,
+            }),
+      },
+      initialData: undefined,
+    }
+  })
+
+export function createSingletonRoute(path: string) {
+  // biome-ignore lint/suspicious/noExplicitAny: dynamic path bypasses route-tree typing
+  const Route: any = createFileRoute(path as never)({
+    validateSearch: searchSchema,
+    loaderDeps: ({ search }: { search: z.infer<typeof searchSchema> }) => ({
+      locale: search.locale,
+    }),
+    loader: async ({
+      params,
+      deps,
+    }: {
+      params: { singleton: string }
+      deps: { locale?: string }
+    }) => {
+      if (getSingletonDefinition(params.singleton) == null) throw notFound()
+      return getSingletonRouteDocument({
+        data: { singleton: params.singleton, locale: deps.locale },
+      })
+    },
+    staleTime: 0,
+    gcTime: 0,
+    shouldReload: true,
+    component: function SingletonRouteComponent() {
+      const routeState = Route.useLoaderData()
+      const { singleton } = Route.useParams() as { singleton: string }
+      const { locale } = Route.useSearch() as z.infer<typeof searchSchema>
+      const definition = getSingletonDefinition(singleton)
+      if (definition == null) throw notFound()
+
+      const { t } = useTranslation('byline-admin')
+      const { contentLocales, defaultContentLocale } = getContentLocaleRouteConfig()
+
+      return (
+        <>
+          <BreadcrumbsClient
+            breadcrumbs={[
+              { label: t('chrome.menu.dashboard'), href: getAdminRoutePath() },
+              { label: definition.label, href: getAdminRoutePath('singletons', singleton) },
+            ]}
+          />
+          <SingletonView
+            singletonDefinition={definition}
+            adminConfig={getSingletonAdminConfig(singleton) ?? undefined}
+            document={routeState.document}
+            initialData={routeState.initialData}
+            locale={locale}
+            contentLocales={contentLocales}
+            defaultContentLocale={defaultContentLocale}
+          />
+        </>
+      )
+    },
+  })
+
+  return Route
+}

package/src/routes/get-multi-collection-definition.ts

@@ -0,0 +1,16 @@
+/**
+ * This Source Code is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * Copyright (c) Infonomic Company Limited
+ */
+
+import type { MultiCollectionDefinition } from '@byline/core'
+import { getCollectionDefinition, isSingleton } from '@byline/core'
+
+/** Resolve only the resource kind supported by the collection route family. */
+export function getMultiCollectionDefinition(path: string): MultiCollectionDefinition | null {
+  const definition = getCollectionDefinition(path)
+  return definition != null && !isSingleton(definition) ? definition : null
+}

package/src/routes/get-singleton-definition.ts

@@ -0,0 +1,16 @@
+/**
+ * This Source Code is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * Copyright (c) Infonomic Company Limited
+ */
+
+import type { SingletonDefinition } from '@byline/core'
+import { getCollectionDefinition, isSingleton } from '@byline/core'
+
+/** Resolve only the resource kind supported by the singleton route family. */
+export function getSingletonDefinition(path: string): SingletonDefinition | null {
+  const definition = getCollectionDefinition(path)
+  return definition != null && isSingleton(definition) ? definition : null
+}