@byline/host-tanstack-start 4.19.0 → 5.1.0

package/dist/server-fns/collections/get.js

@@ -2,11 +2,15 @@ import { createServerFn } from "@tanstack/react-start";
 import { getAdminBylineClient, getAdminRequestContext } from "@byline/client/server";
 import { BylineError, ERR_NOT_FOUND, ErrorCodes, documentAbilityKey, getCollectionSchemasForPath, getLogger, getServerConfig } from "@byline/core";
 import { ensureCollection } from "../../integrations/api-utils.js";
+import { adminSessionMiddleware } from "../../integrations/session-middleware.js";
 import { resolveAdminDocumentRead } from "../admin-document-presentation.js";
+import { withEditableRevision } from "../editable-revision.js";
 import { serialise } from "./utils.js";
 const getDocumentFn = createServerFn({
     method: 'GET'
-}).validator((input)=>input).handler(async ({ data })=>{
+}).middleware([
+    adminSessionMiddleware
+]).validator((input)=>input).handler(async ({ data })=>{
     const { collection: path, id, locale, depth, populateRelations } = data;
     const logger = getLogger();
     const config = await ensureCollection(path);
@@ -18,12 +22,12 @@ const getDocumentFn = createServerFn({
     }).log(logger);
     const client = getAdminBylineClient();
     const handle = client.collection(path);
-    const { options: readOptions, populatedTree } = resolveAdminDocumentRead(config.definition, {
+    const { options: { status: _status, ...readOptions }, populatedTree } = resolveAdminDocumentRead(config.definition, {
         locale,
         depth,
         populateRelations
     });
-    const document = await handle.findById(id, {
+    const document = await handle.findByIdForEdit(id, {
         ...readOptions
     });
     if (!document) throw ERR_NOT_FOUND({
@@ -61,11 +65,11 @@ const getDocumentFn = createServerFn({
     if (scheduledPublicationEnabled) {
         const actor = (await getAdminRequestContext()).actor;
         canSchedulePublication = actor?.hasAbility(documentAbilityKey(config.definition, 'changeStatus')) === true && actor.hasAbility(documentAbilityKey(config.definition, 'publish'));
-        if (canSchedulePublication) scheduledPublish = await handle.getScheduledPublish(id);
+        if (canSchedulePublication) scheduledPublish = document.scheduledPublication;
     }
     const serializedSchedule = null == scheduledPublish ? null : serialise(scheduledPublish);
     return {
-        ...parsed,
+        ...withEditableRevision(parsed, document),
         _publishedVersion: publishedVersion,
         ...restoreWarnings && restoreWarnings.length > 0 ? {
             _restoreWarnings: restoreWarnings
@@ -87,7 +91,9 @@ const getDocumentFn = createServerFn({
 });
 const getDocumentByVersionFn = createServerFn({
     method: 'GET'
-}).validator((input)=>input).handler(async ({ data })=>{
+}).middleware([
+    adminSessionMiddleware
+]).validator((input)=>input).handler(async ({ data })=>{
     const { collection: path, versionId, locale } = data;
     const resolvedLocale = locale ?? 'all';
     const logger = getLogger();

package/dist/server-fns/collections/history.d.ts

@@ -13,7 +13,9 @@ export interface HistorySearchParams {
     desc?: boolean;
     locale?: string;
 }
-export declare const getCollectionDocumentHistory: import("@tanstack/react-start").RequiredFetcher<undefined, (input: {
+export declare const getCollectionDocumentHistory: import("@tanstack/react-start").RequiredFetcher<readonly [import("@tanstack/react-start").FunctionMiddlewareAfterServer<{}, unknown, undefined, undefined, {
+    bylineExpectedSessionId: string | null;
+}, undefined, undefined>], (input: {
     collection: string;
     id: string;
     params: HistorySearchParams;

package/dist/server-fns/collections/history.js

@@ -2,11 +2,14 @@ import { createServerFn } from "@tanstack/react-start";
 import { getAdminBylineClient } from "@byline/client/server";
 import { ERR_NOT_FOUND, getCollectionSchemasForPath, getLogger } from "@byline/core";
 import { ensureCollection } from "../../integrations/api-utils.js";
+import { adminSessionMiddleware } from "../../integrations/session-middleware.js";
 import { resolveActorLabels } from "./actors.js";
 import { serialise } from "./utils.js";
 const getCollectionDocumentHistory = createServerFn({
     method: 'GET'
-}).validator((input)=>input).handler(async ({ data })=>{
+}).middleware([
+    adminSessionMiddleware
+]).validator((input)=>input).handler(async ({ data })=>{
     const { collection: path, id, params } = data;
     const config = await ensureCollection(path);
     if (!config) throw ERR_NOT_FOUND({

package/dist/server-fns/collections/index.d.ts

@@ -4,24 +4,24 @@
  * Each module is self-contained: it defines the TanStack Start server
  * function and exports a clean public API.
  */
-export * from './audit';
-export * from './copy-to-locale';
-export * from './create';
-export * from './delete';
-export * from './delete-locale';
-export * from './delete-outcome';
-export * from './duplicate';
-export * from './get';
-export * from './history';
-export * from './list';
-export * from './reindex';
-export * from './reorder';
-export * from './restore-version';
-export * from './save-outcome';
-export * from './scheduled-publication';
-export * from './set-list-view-preference';
-export * from './stats';
-export * from './status';
-export * from './tree';
-export * from './update';
-export * from './upload';
+export * from './audit.js';
+export * from './copy-to-locale.js';
+export * from './create.js';
+export * from './delete.js';
+export * from './delete-locale.js';
+export * from './delete-outcome.js';
+export * from './duplicate.js';
+export * from './get.js';
+export * from './history.js';
+export * from './list.js';
+export * from './reindex.js';
+export * from './reorder.js';
+export * from './restore-version.js';
+export * from './save-outcome.js';
+export * from './scheduled-publication.js';
+export * from './set-list-view-preference.js';
+export * from './stats.js';
+export * from './status.js';
+export * from './tree.js';
+export * from './update.js';
+export * from './upload.js';

package/dist/server-fns/collections/list.d.ts

@@ -15,7 +15,9 @@ export interface CollectionSearchParams {
     status?: string;
     fields?: string[];
 }
-export declare const getCollectionDocuments: import("@tanstack/react-start").RequiredFetcher<undefined, (input: {
+export declare const getCollectionDocuments: import("@tanstack/react-start").RequiredFetcher<readonly [import("@tanstack/react-start").FunctionMiddlewareAfterServer<{}, unknown, undefined, undefined, {
+    bylineExpectedSessionId: string | null;
+}, undefined, undefined>], (input: {
     collection: string;
     params: CollectionSearchParams;
 }) => {

package/dist/server-fns/collections/list.js

@@ -4,11 +4,15 @@ import { getAdminBylineClient, getAdminRequestContext } from "@byline/client/ser
 import { ERR_NOT_FOUND, buildRelationSummaryPopulateMap, getCollectionAdminConfig, getCollectionDefinition, getCollectionSchemasForPath, getLogger, getServerConfig } from "@byline/core";
 import { ensureCollection } from "../../integrations/api-utils.js";
 import { bylineCore } from "../../integrations/byline-core.js";
+import { adminSessionMiddleware } from "../../integrations/session-middleware.js";
+import { withEditableRevision } from "../editable-revision.js";
 import { resolveListViewState, sortableFieldNames } from "./list-view-state.js";
 import { serialise } from "./utils.js";
 const getCollectionDocuments = createServerFn({
     method: 'GET'
-}).validator((input)=>input).handler(async ({ data })=>{
+}).middleware([
+    adminSessionMiddleware
+]).validator((input)=>input).handler(async ({ data })=>{
     const { collection: path, params } = data;
     const config = await ensureCollection(path);
     if (!config) throw ERR_NOT_FOUND({
@@ -61,7 +65,7 @@ const getCollectionDocuments = createServerFn({
         }));
     const hasRelations = Object.keys(populateMap).length > 0;
     const populate = hasRelations ? populateMap : void 0;
-    const result = await handle.find({
+    const result = await handle.findForEdit({
         where: Object.keys(where).length > 0 ? where : void 0,
         sort: viewState.sort,
         locale: params.locale ?? 'en',
@@ -70,7 +74,6 @@ const getCollectionDocuments = createServerFn({
         select: params.fields,
         populate,
         depth: hasRelations ? 1 : void 0,
-        status: 'any',
         onMissingLocale: 'empty'
     });
     const documentIds = result.docs.map((d)=>d.id);
@@ -104,6 +107,14 @@ const getCollectionDocuments = createServerFn({
     const serialised = serialise(response);
     const { list } = getCollectionSchemasForPath(path);
     if (hasRelations) return serialised;
-    return list.parse(serialised);
+    const parsed = list.parse(serialised);
+    const observations = new Map(result.docs.map((doc)=>[
+            doc.id,
+            doc
+        ]));
+    return {
+        ...parsed,
+        docs: parsed.docs.map((doc)=>withEditableRevision(doc, observations.get(doc.id)))
+    };
 });
 export { getCollectionDocuments };

package/dist/server-fns/collections/reindex.d.ts

@@ -7,7 +7,9 @@
  */
 import type { ReindexResult } from '@byline/client';
 export type { ReindexResult };
-export declare const reindexCollection: import("@tanstack/react-start").RequiredFetcher<undefined, (input: {
+export declare const reindexCollection: import("@tanstack/react-start").RequiredFetcher<readonly [import("@tanstack/react-start").FunctionMiddlewareAfterServer<{}, unknown, undefined, undefined, {
+    bylineExpectedSessionId: string | null;
+}, undefined, undefined>], (input: {
     collection: string;
 }) => {
     collection: string;

package/dist/server-fns/collections/reindex.js

@@ -2,9 +2,12 @@ import { createServerFn } from "@tanstack/react-start";
 import { getAdminBylineClient } from "@byline/client/server";
 import { ERR_NOT_FOUND, getLogger } from "@byline/core";
 import { ensureCollection } from "../../integrations/api-utils.js";
+import { adminSessionMiddleware } from "../../integrations/session-middleware.js";
 const reindexCollection = createServerFn({
     method: 'POST'
-}).validator((input)=>input).handler(async ({ data })=>{
+}).middleware([
+    adminSessionMiddleware
+]).validator((input)=>input).handler(async ({ data })=>{
     const { collection } = data;
     const config = await ensureCollection(collection);
     if (!config) throw ERR_NOT_FOUND({

package/dist/server-fns/collections/reorder.d.ts

@@ -5,17 +5,25 @@
  *
  * Copyright (c) Infonomic Company Limited
  */
-export declare const reorderCollectionDocument: import("@tanstack/react-start").RequiredFetcher<undefined, (input: {
+export declare const reorderCollectionDocument: import("@tanstack/react-start").RequiredFetcher<readonly [import("@tanstack/react-start").FunctionMiddlewareAfterServer<{}, unknown, undefined, undefined, {
+    bylineExpectedSessionId: string | null;
+}, undefined, undefined>], (input: {
+    expectedRevision: number;
     collection: string;
     documentId: string;
     beforeDocumentId?: string | null;
     afterDocumentId?: string | null;
 }) => {
+    expectedRevision: number;
     collection: string;
     documentId: string;
     beforeDocumentId?: string | null;
     afterDocumentId?: string | null;
 }, Promise<{
-    status: 'ok';
+    documentId: string;
+    revision: number;
+    affectedDocuments: import("@byline/core").DocumentRevisionReceipt[];
+    scheduledPublicationsNeedReconfirmation: boolean;
     orderKey: string;
+    status: 'ok';
 }>>;

package/dist/server-fns/collections/reorder.js

@@ -1,10 +1,14 @@
 import { createServerFn } from "@tanstack/react-start";
 import { getAdminRequestContext } from "@byline/client/server";
-import { ERR_NOT_FOUND, ERR_VALIDATION, assertActorCanPerform, generateKeyBetween, generateNKeysBetween, getLogger, getServerConfig } from "@byline/core";
+import { ERR_NOT_FOUND, getLogger, getServerConfig, reorderDocument } from "@byline/core";
 import { ensureCollection } from "../../integrations/api-utils.js";
+import { adminSessionMiddleware } from "../../integrations/session-middleware.js";
+import { withDocumentMutationErrors } from "../document-mutation-errors.js";
 const reorderCollectionDocument = createServerFn({
     method: 'POST'
-}).validator((input)=>input).handler(async ({ data: input })=>{
+}).middleware([
+    adminSessionMiddleware
+]).validator((input)=>input).handler(withDocumentMutationErrors(async ({ data: input })=>{
     const { collection: path, documentId, beforeDocumentId, afterDocumentId } = input;
     const logger = getLogger();
     const config = await ensureCollection(path);
@@ -14,83 +18,26 @@ const reorderCollectionDocument = createServerFn({
             collectionPath: path
         }
     }).log(logger);
-    if (true !== config.definition.orderable) throw ERR_VALIDATION({
-        message: `collection '${path}' is not orderable; set \`orderable: true\` on its collection definition to enable reordering`,
-        details: {
-            collectionPath: path
-        }
-    }).log(logger);
-    const requestContext = await getAdminRequestContext();
-    assertActorCanPerform(requestContext, config.definition, 'update');
     const serverConfig = getServerConfig();
-    const collectionId = config.collection.id;
-    const canonical = await serverConfig.db.queries.documents.getCanonicalDocumentOrder({
-        collection_id: collectionId
-    });
-    let corrupted = false;
-    {
-        const seen = new Set();
-        let lastKey = null;
-        for (const doc of canonical)if (null != doc.order_key) {
-            if (seen.has(doc.order_key)) {
-                corrupted = true;
-                break;
-            }
-            if (null != lastKey && doc.order_key <= lastKey) {
-                corrupted = true;
-                break;
-            }
-            seen.add(doc.order_key);
-            lastKey = doc.order_key;
-        }
-    }
-    if (corrupted) {
-        const allKeys = generateNKeysBetween(null, null, canonical.length);
-        for(let i = 0; i < canonical.length; i++)await serverConfig.db.commands.documents.setOrderKey({
-            document_id: canonical[i]?.id,
-            order_key: allKeys[i]
-        });
-    } else {
-        const firstNullIdx = canonical.findIndex((d)=>null == d.order_key);
-        if (-1 !== firstNullIdx) {
-            const nullDocs = canonical.slice(firstNullIdx);
-            const lastExistingKey = 0 === firstNullIdx ? null : canonical[firstNullIdx - 1]?.order_key;
-            const newKeys = generateNKeysBetween(lastExistingKey, null, nullDocs.length);
-            for(let i = 0; i < nullDocs.length; i++)await serverConfig.db.commands.documents.setOrderKey({
-                document_id: nullDocs[i]?.id,
-                order_key: newKeys[i]
-            });
-        }
-    }
-    const { left, right } = await serverConfig.db.queries.documents.getNeighborOrderKeys({
-        collection_id: collectionId,
-        before_document_id: beforeDocumentId ?? null,
-        after_document_id: afterDocumentId ?? null
-    });
-    let newKey;
-    try {
-        newKey = generateKeyBetween(left, right);
-    } catch (err) {
-        throw ERR_VALIDATION({
-            message: 'cannot generate order_key between supplied neighbors',
-            details: {
-                collectionPath: path,
-                documentId,
-                beforeDocumentId,
-                afterDocumentId,
-                left,
-                right,
-                cause: err instanceof Error ? err.message : String(err)
-            }
-        }).log(logger);
-    }
-    await serverConfig.db.commands.documents.setOrderKey({
-        document_id: documentId,
-        order_key: newKey
+    const result = await reorderDocument({
+        db: serverConfig.db,
+        definition: config.definition,
+        collectionId: config.collection.id,
+        collectionVersion: config.collection.version,
+        collectionPath: path,
+        requestContext: await getAdminRequestContext(),
+        logger,
+        defaultLocale: serverConfig.i18n.content.defaultLocale,
+        slugifier: serverConfig.slugifier
+    }, {
+        documentId,
+        expectedRevision: input.expectedRevision,
+        beforeDocumentId,
+        afterDocumentId
     });
     return {
         status: 'ok',
-        orderKey: newKey
+        ...result
     };
-});
+}));
 export { reorderCollectionDocument };

package/dist/server-fns/collections/restore-version.d.ts

@@ -5,17 +5,22 @@
  *
  * Copyright (c) Infonomic Company Limited
  */
-export declare const restoreDocumentVersion: import("@tanstack/react-start").RequiredFetcher<undefined, (input: {
+export declare const restoreDocumentVersion: import("@tanstack/react-start").RequiredFetcher<readonly [import("@tanstack/react-start").FunctionMiddlewareAfterServer<{}, unknown, undefined, undefined, {
+    bylineExpectedSessionId: string | null;
+}, undefined, undefined>], (input: {
+    expectedRevision: number;
     collection: string;
     id: string;
     versionId: string;
 }) => {
+    expectedRevision: number;
     collection: string;
     id: string;
     versionId: string;
 }, Promise<import("./save-outcome.js").CollectionDocumentCommittedHookFailureResponse | {
     status: 'ok';
     documentId: string;
+    revision: number;
     documentVersionId: string;
     sourceVersionId: string;
 }>>;

package/dist/server-fns/collections/restore-version.js

@@ -3,10 +3,14 @@ import { getAdminRequestContext } from "@byline/client/server";
 import { ERR_NOT_FOUND, getLogger, getServerConfig } from "@byline/core";
 import { restoreDocumentVersion } from "@byline/core/services";
 import { ensureCollection } from "../../integrations/api-utils.js";
+import { adminSessionMiddleware } from "../../integrations/session-middleware.js";
+import { withDocumentMutationErrors } from "../document-mutation-errors.js";
 import { toCommittedDocumentHookFailureResponse } from "./save-outcome.js";
 const restore_version_restoreDocumentVersion = createServerFn({
     method: 'POST'
-}).validator((input)=>input).handler(async ({ data: input })=>{
+}).middleware([
+    adminSessionMiddleware
+]).validator((input)=>input).handler(withDocumentMutationErrors(async ({ data: input })=>{
     const { collection: path, id, versionId } = input;
     const logger = getLogger();
     const config = await ensureCollection(path);
@@ -31,11 +35,13 @@ const restore_version_restoreDocumentVersion = createServerFn({
     try {
         const result = await restoreDocumentVersion(ctx, {
             documentId: id,
+            expectedRevision: input.expectedRevision,
             sourceVersionId: versionId
         });
         return {
             status: 'ok',
             documentId: result.documentId,
+            revision: result.revision,
             documentVersionId: result.documentVersionId,
             sourceVersionId: result.sourceVersionId
         };
@@ -44,5 +50,5 @@ const restore_version_restoreDocumentVersion = createServerFn({
         if (null != committedFailure) return committedFailure;
         throw error;
     }
-});
+}));
 export { restore_version_restoreDocumentVersion as restoreDocumentVersion };

package/dist/server-fns/collections/save-outcome.d.ts

@@ -10,6 +10,7 @@ export interface CollectionDocumentCommittedHookFailureResponse {
     status: 'committed-hook-failed';
     documentId: string;
     documentVersionId: string;
+    revision: number;
     sideEffectFailure: {
         phase: DocumentHookCommittedPhase;
         code: DocumentHookSideEffectCode;

package/dist/server-fns/collections/save-outcome.js

@@ -6,6 +6,7 @@ function toCommittedDocumentHookFailureResponse(error) {
         status: 'committed-hook-failed',
         documentId: details.documentId,
         documentVersionId: details.documentVersionId,
+        revision: details.revision,
         sideEffectFailure: {
             phase: details.phase,
             code: details.sideEffectCode

package/dist/server-fns/collections/scheduled-publication.d.ts

@@ -31,6 +31,7 @@ export type SerializedDocumentPublishSchedule = Omit<DocumentPublishScheduleInfo
     nextAttemptAt: string;
 };
 export interface ScheduledPublicationListItem extends SerializedDocumentPublishSchedule {
+    revision: number;
     collectionPath: string;
     collectionLabel: string;
     documentPath: string | null;
@@ -54,41 +55,97 @@ export interface ScheduledPublicationListResponse {
     runtime: ScheduledPublicationRuntime;
 }
 /** Authenticated feature discovery for the admin shell and health warning. */
-export declare const getScheduledPublicationRuntime: import("@tanstack/react-start").OptionalFetcher<undefined, undefined, Promise<ScheduledPublicationRuntime>>;
-export declare const scheduleCollectionDocumentPublish: import("@tanstack/react-start").RequiredFetcher<undefined, (input: {
+export declare const getScheduledPublicationRuntime: import("@tanstack/react-start").OptionalFetcher<readonly [import("@tanstack/react-start").FunctionMiddlewareAfterServer<{}, unknown, undefined, undefined, {
+    bylineExpectedSessionId: string | null;
+}, undefined, undefined>], undefined, Promise<ScheduledPublicationRuntime>>;
+export declare const scheduleCollectionDocumentPublish: import("@tanstack/react-start").RequiredFetcher<readonly [import("@tanstack/react-start").FunctionMiddlewareAfterServer<{}, unknown, undefined, undefined, {
+    bylineExpectedSessionId: string | null;
+}, undefined, undefined>], (input: {
+    expectedRevision: number;
     collection: string;
     id: string;
     publishAt: string;
     expectedVersionId: string;
 }) => {
+    expectedRevision: number;
     collection: string;
     id: string;
     publishAt: string;
     expectedVersionId: string;
-}, Promise<SerializedDocumentPublishSchedule>>;
-export declare const confirmCollectionDocumentScheduledPublish: import("@tanstack/react-start").RequiredFetcher<undefined, (input: {
+}, Promise<{
+    authorizedRevision: number | null;
+    documentId: string;
+    collectionId: string;
+    targetVersionId: string;
+    state: DocumentPublishScheduleState;
+    suspendedReason: ("content_edited" | "document_metadata_changed" | "upgrade_invalidated") | null;
+    scheduledBy: string | null;
+    lastAuthorizedBy: string | null;
+    attemptCount: number;
+    lastError: string | null;
+    publishAt: string;
+    suspendedAt: string | null;
+    lastAuthorizedAt: string;
+    scheduledAt: string;
+    updatedAt: string;
+    lastAttemptAt: string | null;
+    nextAttemptAt: string;
+    revision: number;
+}>>;
+export declare const confirmCollectionDocumentScheduledPublish: import("@tanstack/react-start").RequiredFetcher<readonly [import("@tanstack/react-start").FunctionMiddlewareAfterServer<{}, unknown, undefined, undefined, {
+    bylineExpectedSessionId: string | null;
+}, undefined, undefined>], (input: {
+    expectedRevision: number;
     collection: string;
     id: string;
     expectedVersionId: string;
 }) => {
+    expectedRevision: number;
     collection: string;
     id: string;
     expectedVersionId: string;
-}, Promise<SerializedDocumentPublishSchedule>>;
-export declare const cancelCollectionDocumentScheduledPublish: import("@tanstack/react-start").RequiredFetcher<undefined, (input: {
+}, Promise<{
+    authorizedRevision: number | null;
+    documentId: string;
+    collectionId: string;
+    targetVersionId: string;
+    state: DocumentPublishScheduleState;
+    suspendedReason: ("content_edited" | "document_metadata_changed" | "upgrade_invalidated") | null;
+    scheduledBy: string | null;
+    lastAuthorizedBy: string | null;
+    attemptCount: number;
+    lastError: string | null;
+    publishAt: string;
+    suspendedAt: string | null;
+    lastAuthorizedAt: string;
+    scheduledAt: string;
+    updatedAt: string;
+    lastAttemptAt: string | null;
+    nextAttemptAt: string;
+    revision: number;
+}>>;
+export declare const cancelCollectionDocumentScheduledPublish: import("@tanstack/react-start").RequiredFetcher<readonly [import("@tanstack/react-start").FunctionMiddlewareAfterServer<{}, unknown, undefined, undefined, {
+    bylineExpectedSessionId: string | null;
+}, undefined, undefined>], (input: {
+    expectedRevision: number;
     collection: string;
     id: string;
 }) => {
+    expectedRevision: number;
     collection: string;
     id: string;
 }, Promise<{
     status: 'not_found';
+    revision: number;
     schedule?: undefined;
 } | {
     status: 'cancelled';
     schedule: SerializedDocumentPublishSchedule;
+    revision: number;
 }>>;
-export declare const listScheduledPublications: import("@tanstack/react-start").RequiredFetcher<undefined, (input: {
+export declare const listScheduledPublications: import("@tanstack/react-start").RequiredFetcher<readonly [import("@tanstack/react-start").FunctionMiddlewareAfterServer<{}, unknown, undefined, undefined, {
+    bylineExpectedSessionId: string | null;
+}, undefined, undefined>], (input: {
     states?: readonly DocumentPublishScheduleState[];
     lastAuthorizedBy?: string;
     page?: number;