payload 4.0.0-internal.ea6e8f8 → 4.0.0-internal.ee5d8bd

package/dist/uploads/uploadFileRollback.js

@@ -1,269 +0,0 @@
-import { randomUUID } from 'node:crypto';
-import { constants } from 'node:fs';
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import { getFileHandleIdentity, getFileIdentity, hasFileIdentity, hasRenameStableFileIdentity } from './fileIdentity.js';
-import { linkFileWithoutOverwrite } from './linkFileWithoutOverwrite.js';
-export const stageUploadFileRollback = async ({ file, rollbacks })=>{
-    let rollback = rollbacks.get(file.path);
-    if (!rollback) {
-        rollback = await createUploadFileRollback({
-            filePath: file.path
-        });
-        rollbacks.set(file.path, rollback);
-    }
-    const stagedFilePath = path.join(rollback.directoryPath, `upload-${randomUUID()}`);
-    rollback.stagedFilePaths.add(stagedFilePath);
-    return {
-        ...file,
-        path: stagedFilePath
-    };
-};
-export const publishUploadedFile = async ({ file, rollbacks, stagedFile })=>{
-    const rollback = rollbacks.get(file.path);
-    if (!rollback || !rollback.stagedFilePaths.has(stagedFile.path)) {
-        throw new Error('The staged upload does not belong to this operation.');
-    }
-    const precedingPublish = rollback.publishQueue;
-    let releasePublish;
-    rollback.publishQueue = new Promise((resolve)=>{
-        releasePublish = resolve;
-    });
-    await precedingPublish;
-    try {
-        const fileHandle = await fs.open(stagedFile.path, 'r');
-        try {
-            rollback.publicationState = 'indeterminate';
-            const quarantinedDestination = await quarantineUploadDestination({
-                rollback
-            });
-            const hasExpectedDestination = rollback.expectedDestinationFileIdentity !== undefined;
-            const hasMatchingDestination = hasExpectedDestination ? hasRenameStableFileIdentity({
-                actual: quarantinedDestination?.fileIdentity,
-                expected: rollback.expectedDestinationFileIdentity
-            }) : quarantinedDestination === undefined;
-            if (!hasMatchingDestination) {
-                rollback.publicationState = 'failed';
-                if (quarantinedDestination) {
-                    await restoreQuarantinedUploadDestination({
-                        quarantinedDestination,
-                        rollback
-                    });
-                }
-                throw new Error('The upload destination changed before the staged file was published.');
-            }
-            try {
-                await linkFileWithoutOverwrite({
-                    sourceFilePath: stagedFile.path,
-                    targetFilePath: rollback.filePath
-                });
-            } catch (error) {
-                rollback.publicationState = 'failed';
-                if (quarantinedDestination) {
-                    try {
-                        await restoreQuarantinedUploadDestination({
-                            quarantinedDestination,
-                            rollback
-                        });
-                    } catch (restoreError) {
-                        throw new AggregateError([
-                            error,
-                            restoreError
-                        ], 'The staged upload could not be installed or its prior destination restored.');
-                    }
-                }
-                throw error;
-            }
-            rollback.publicationState = 'indeterminate';
-            rollback.uploadedFileIdentity = await getFileHandleIdentity({
-                fileHandle
-            });
-            rollback.expectedDestinationFileIdentity = rollback.uploadedFileIdentity;
-            rollback.publicationState = 'owned';
-        } finally{
-            await fileHandle.close();
-        }
-    } finally{
-        releasePublish();
-    }
-};
-export const cleanupUploadFileRollbacks = async ({ rollbacks })=>{
-    const errors = [];
-    for (const rollback of rollbacks.values()){
-        try {
-            await fs.rm(rollback.directoryPath, {
-                force: true,
-                recursive: true
-            });
-        } catch (error) {
-            errors.push(error);
-        }
-    }
-    rollbacks.clear();
-    throwCollectedErrors({
-        errors
-    });
-};
-export const rollbackUploadFiles = async ({ rollbacks })=>{
-    const errors = [];
-    for (const rollback of [
-        ...rollbacks.values()
-    ].reverse()){
-        try {
-            await rollbackUploadFile({
-                rollback
-            });
-            await fs.rm(rollback.directoryPath, {
-                force: true,
-                recursive: true
-            });
-            rollbacks.delete(rollback.filePath);
-        } catch (error) {
-            errors.push(error);
-        }
-    }
-    throwCollectedErrors({
-        errors
-    });
-};
-const createUploadFileRollback = async ({ filePath })=>{
-    const originalFileIdentity = await getFileIdentity({
-        filePath
-    });
-    if (originalFileIdentity && !originalFileIdentity.isRegularFile) {
-        throw new Error('The upload destination must be a regular file.');
-    }
-    const directoryPath = path.join(path.dirname(filePath), `.payload-upload-rollback-${randomUUID()}`);
-    await fs.mkdir(directoryPath, {
-        mode: 0o700
-    });
-    const rollback = {
-        directoryPath,
-        expectedDestinationFileIdentity: originalFileIdentity,
-        filePath,
-        publicationState: 'not-published',
-        publishQueue: Promise.resolve(),
-        stagedFilePaths: new Set()
-    };
-    if (!originalFileIdentity) {
-        return rollback;
-    }
-    const backupFilePath = path.join(directoryPath, 'backup');
-    try {
-        await fs.copyFile(filePath, backupFilePath, constants.COPYFILE_EXCL);
-        const [currentOriginalFileIdentity, backupFileIdentity] = await Promise.all([
-            getFileIdentity({
-                filePath
-            }),
-            getFileIdentity({
-                filePath: backupFilePath
-            })
-        ]);
-        if (!hasFileIdentity({
-            actual: currentOriginalFileIdentity,
-            expected: originalFileIdentity
-        }) || !backupFileIdentity) {
-            throw new Error('The upload file changed while its rollback backup was being created.');
-        }
-        rollback.backupFileIdentity = backupFileIdentity;
-        rollback.backupFilePath = backupFilePath;
-        return rollback;
-    } catch (error) {
-        await fs.rm(directoryPath, {
-            force: true,
-            recursive: true
-        }).catch(()=>undefined);
-        throw error;
-    }
-};
-const rollbackUploadFile = async ({ rollback })=>{
-    if (rollback.publicationState === 'not-published') {
-        return;
-    }
-    if (rollback.publicationState === 'failed' || rollback.publicationState === 'indeterminate' || !rollback.uploadedFileIdentity) {
-        throw new Error('The published upload could not be identified safely for rollback.');
-    }
-    const quarantinedFilePath = path.join(rollback.directoryPath, `published-${randomUUID()}`);
-    try {
-        await fs.rename(rollback.filePath, quarantinedFilePath);
-    } catch (error) {
-        if (error.code === 'ENOENT') {
-            await restoreBackupIfPresent({
-                rollback
-            });
-            return;
-        }
-        throw error;
-    }
-    const quarantinedFileIdentity = await getFileIdentity({
-        filePath: quarantinedFilePath
-    });
-    if (!hasRenameStableFileIdentity({
-        actual: quarantinedFileIdentity,
-        expected: rollback.uploadedFileIdentity
-    })) {
-        await linkFileWithoutOverwrite({
-            sourceFilePath: quarantinedFilePath,
-            targetFilePath: rollback.filePath
-        });
-        return;
-    }
-    await restoreBackupIfPresent({
-        rollback
-    });
-};
-const quarantineUploadDestination = async ({ rollback })=>{
-    const quarantinedFilePath = path.join(rollback.directoryPath, `destination-${randomUUID()}`);
-    try {
-        await fs.rename(rollback.filePath, quarantinedFilePath);
-    } catch (error) {
-        if (error.code === 'ENOENT') {
-            return undefined;
-        }
-        throw error;
-    }
-    const fileIdentity = await getFileIdentity({
-        filePath: quarantinedFilePath
-    });
-    if (!fileIdentity) {
-        throw new Error('The upload destination was not present after it was quarantined.');
-    }
-    return {
-        fileIdentity,
-        filePath: quarantinedFilePath
-    };
-};
-const restoreQuarantinedUploadDestination = async ({ quarantinedDestination, rollback })=>{
-    await linkFileWithoutOverwrite({
-        sourceFilePath: quarantinedDestination.filePath,
-        targetFilePath: rollback.filePath
-    });
-};
-const restoreBackupIfPresent = async ({ rollback })=>{
-    if (!rollback.backupFileIdentity || !rollback.backupFilePath) {
-        return;
-    }
-    const currentBackupFileIdentity = await getFileIdentity({
-        filePath: rollback.backupFilePath
-    });
-    if (!hasFileIdentity({
-        actual: currentBackupFileIdentity,
-        expected: rollback.backupFileIdentity
-    })) {
-        throw new Error('The upload rollback backup no longer belongs to this operation.');
-    }
-    await linkFileWithoutOverwrite({
-        sourceFilePath: rollback.backupFilePath,
-        targetFilePath: rollback.filePath
-    });
-};
-const throwCollectedErrors = ({ errors })=>{
-    if (errors.length === 1) {
-        throw errors[0];
-    }
-    if (errors.length > 1) {
-        throw new AggregateError(errors, 'Multiple upload rollback tasks failed.');
-    }
-};
-
-//# sourceMappingURL=uploadFileRollback.js.map

package/dist/uploads/uploadFileRollback.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/uploads/uploadFileRollback.ts"],"sourcesContent":["import { randomUUID } from 'node:crypto'\nimport { constants } from 'node:fs'\nimport fs from 'node:fs/promises'\nimport path from 'node:path'\n\nimport type { FileIdentity } from './fileIdentity.js'\nimport type { FileToSave } from './types.js'\n\nimport {\n  getFileHandleIdentity,\n  getFileIdentity,\n  hasFileIdentity,\n  hasRenameStableFileIdentity,\n} from './fileIdentity.js'\nimport { linkFileWithoutOverwrite } from './linkFileWithoutOverwrite.js'\n\ntype UploadFileRollback = {\n  backupFileIdentity?: FileIdentity\n  backupFilePath?: string\n  directoryPath: string\n  expectedDestinationFileIdentity?: FileIdentity\n  filePath: string\n  publicationState: 'failed' | 'indeterminate' | 'not-published' | 'owned'\n  publishQueue: Promise<void>\n  stagedFilePaths: Set<string>\n  uploadedFileIdentity?: FileIdentity\n}\n\nexport type UploadFileRollbacks = Map<string, UploadFileRollback>\n\nexport const stageUploadFileRollback = async ({\n  file,\n  rollbacks,\n}: {\n  file: FileToSave\n  rollbacks: UploadFileRollbacks\n}): Promise<FileToSave> => {\n  let rollback = rollbacks.get(file.path)\n\n  if (!rollback) {\n    rollback = await createUploadFileRollback({ filePath: file.path })\n    rollbacks.set(file.path, rollback)\n  }\n\n  const stagedFilePath = path.join(rollback.directoryPath, `upload-${randomUUID()}`)\n\n  rollback.stagedFilePaths.add(stagedFilePath)\n\n  return { ...file, path: stagedFilePath }\n}\n\nexport const publishUploadedFile = async ({\n  file,\n  rollbacks,\n  stagedFile,\n}: {\n  file: FileToSave\n  rollbacks: UploadFileRollbacks\n  stagedFile: FileToSave\n}): Promise<void> => {\n  const rollback = rollbacks.get(file.path)\n\n  if (!rollback || !rollback.stagedFilePaths.has(stagedFile.path)) {\n    throw new Error('The staged upload does not belong to this operation.')\n  }\n\n  const precedingPublish = rollback.publishQueue\n  let releasePublish!: () => void\n\n  rollback.publishQueue = new Promise<void>((resolve) => {\n    releasePublish = resolve\n  })\n\n  await precedingPublish\n\n  try {\n    const fileHandle = await fs.open(stagedFile.path, 'r')\n\n    try {\n      rollback.publicationState = 'indeterminate'\n      const quarantinedDestination = await quarantineUploadDestination({ rollback })\n      const hasExpectedDestination = rollback.expectedDestinationFileIdentity !== undefined\n      const hasMatchingDestination = hasExpectedDestination\n        ? hasRenameStableFileIdentity({\n            actual: quarantinedDestination?.fileIdentity,\n            expected: rollback.expectedDestinationFileIdentity!,\n          })\n        : quarantinedDestination === undefined\n\n      if (!hasMatchingDestination) {\n        rollback.publicationState = 'failed'\n\n        if (quarantinedDestination) {\n          await restoreQuarantinedUploadDestination({ quarantinedDestination, rollback })\n        }\n\n        throw new Error('The upload destination changed before the staged file was published.')\n      }\n\n      try {\n        await linkFileWithoutOverwrite({\n          sourceFilePath: stagedFile.path,\n          targetFilePath: rollback.filePath,\n        })\n      } catch (error) {\n        rollback.publicationState = 'failed'\n\n        if (quarantinedDestination) {\n          try {\n            await restoreQuarantinedUploadDestination({ quarantinedDestination, rollback })\n          } catch (restoreError) {\n            throw new AggregateError(\n              [error, restoreError],\n              'The staged upload could not be installed or its prior destination restored.',\n            )\n          }\n        }\n\n        throw error\n      }\n\n      rollback.publicationState = 'indeterminate'\n      rollback.uploadedFileIdentity = await getFileHandleIdentity({ fileHandle })\n      rollback.expectedDestinationFileIdentity = rollback.uploadedFileIdentity\n      rollback.publicationState = 'owned'\n    } finally {\n      await fileHandle.close()\n    }\n  } finally {\n    releasePublish()\n  }\n}\n\nexport const cleanupUploadFileRollbacks = async ({\n  rollbacks,\n}: {\n  rollbacks: UploadFileRollbacks\n}): Promise<void> => {\n  const errors: unknown[] = []\n\n  for (const rollback of rollbacks.values()) {\n    try {\n      await fs.rm(rollback.directoryPath, { force: true, recursive: true })\n    } catch (error) {\n      errors.push(error)\n    }\n  }\n\n  rollbacks.clear()\n  throwCollectedErrors({ errors })\n}\n\nexport const rollbackUploadFiles = async ({\n  rollbacks,\n}: {\n  rollbacks: UploadFileRollbacks\n}): Promise<void> => {\n  const errors: unknown[] = []\n\n  for (const rollback of [...rollbacks.values()].reverse()) {\n    try {\n      await rollbackUploadFile({ rollback })\n      await fs.rm(rollback.directoryPath, { force: true, recursive: true })\n      rollbacks.delete(rollback.filePath)\n    } catch (error) {\n      errors.push(error)\n    }\n  }\n\n  throwCollectedErrors({ errors })\n}\n\nconst createUploadFileRollback = async ({\n  filePath,\n}: {\n  filePath: string\n}): Promise<UploadFileRollback> => {\n  const originalFileIdentity = await getFileIdentity({ filePath })\n\n  if (originalFileIdentity && !originalFileIdentity.isRegularFile) {\n    throw new Error('The upload destination must be a regular file.')\n  }\n\n  const directoryPath = path.join(\n    path.dirname(filePath),\n    `.payload-upload-rollback-${randomUUID()}`,\n  )\n\n  await fs.mkdir(directoryPath, { mode: 0o700 })\n  const rollback: UploadFileRollback = {\n    directoryPath,\n    expectedDestinationFileIdentity: originalFileIdentity,\n    filePath,\n    publicationState: 'not-published',\n    publishQueue: Promise.resolve(),\n    stagedFilePaths: new Set(),\n  }\n\n  if (!originalFileIdentity) {\n    return rollback\n  }\n\n  const backupFilePath = path.join(directoryPath, 'backup')\n\n  try {\n    await fs.copyFile(filePath, backupFilePath, constants.COPYFILE_EXCL)\n\n    const [currentOriginalFileIdentity, backupFileIdentity] = await Promise.all([\n      getFileIdentity({ filePath }),\n      getFileIdentity({ filePath: backupFilePath }),\n    ])\n\n    if (\n      !hasFileIdentity({ actual: currentOriginalFileIdentity, expected: originalFileIdentity }) ||\n      !backupFileIdentity\n    ) {\n      throw new Error('The upload file changed while its rollback backup was being created.')\n    }\n\n    rollback.backupFileIdentity = backupFileIdentity\n    rollback.backupFilePath = backupFilePath\n    return rollback\n  } catch (error) {\n    await fs.rm(directoryPath, { force: true, recursive: true }).catch(() => undefined)\n    throw error\n  }\n}\n\nconst rollbackUploadFile = async ({\n  rollback,\n}: {\n  rollback: UploadFileRollback\n}): Promise<void> => {\n  if (rollback.publicationState === 'not-published') {\n    return\n  }\n\n  if (\n    rollback.publicationState === 'failed' ||\n    rollback.publicationState === 'indeterminate' ||\n    !rollback.uploadedFileIdentity\n  ) {\n    throw new Error('The published upload could not be identified safely for rollback.')\n  }\n\n  const quarantinedFilePath = path.join(rollback.directoryPath, `published-${randomUUID()}`)\n\n  try {\n    await fs.rename(rollback.filePath, quarantinedFilePath)\n  } catch (error) {\n    if ((error as NodeJS.ErrnoException).code === 'ENOENT') {\n      await restoreBackupIfPresent({ rollback })\n      return\n    }\n\n    throw error\n  }\n\n  const quarantinedFileIdentity = await getFileIdentity({ filePath: quarantinedFilePath })\n\n  if (\n    !hasRenameStableFileIdentity({\n      actual: quarantinedFileIdentity,\n      expected: rollback.uploadedFileIdentity,\n    })\n  ) {\n    await linkFileWithoutOverwrite({\n      sourceFilePath: quarantinedFilePath,\n      targetFilePath: rollback.filePath,\n    })\n    return\n  }\n\n  await restoreBackupIfPresent({ rollback })\n}\n\nconst quarantineUploadDestination = async ({\n  rollback,\n}: {\n  rollback: UploadFileRollback\n}): Promise<{ fileIdentity: FileIdentity; filePath: string } | undefined> => {\n  const quarantinedFilePath = path.join(rollback.directoryPath, `destination-${randomUUID()}`)\n\n  try {\n    await fs.rename(rollback.filePath, quarantinedFilePath)\n  } catch (error) {\n    if ((error as NodeJS.ErrnoException).code === 'ENOENT') {\n      return undefined\n    }\n\n    throw error\n  }\n\n  const fileIdentity = await getFileIdentity({ filePath: quarantinedFilePath })\n\n  if (!fileIdentity) {\n    throw new Error('The upload destination was not present after it was quarantined.')\n  }\n\n  return { fileIdentity, filePath: quarantinedFilePath }\n}\n\nconst restoreQuarantinedUploadDestination = async ({\n  quarantinedDestination,\n  rollback,\n}: {\n  quarantinedDestination: { fileIdentity: FileIdentity; filePath: string }\n  rollback: UploadFileRollback\n}): Promise<void> => {\n  await linkFileWithoutOverwrite({\n    sourceFilePath: quarantinedDestination.filePath,\n    targetFilePath: rollback.filePath,\n  })\n}\n\nconst restoreBackupIfPresent = async ({\n  rollback,\n}: {\n  rollback: UploadFileRollback\n}): Promise<void> => {\n  if (!rollback.backupFileIdentity || !rollback.backupFilePath) {\n    return\n  }\n\n  const currentBackupFileIdentity = await getFileIdentity({ filePath: rollback.backupFilePath })\n\n  if (\n    !hasFileIdentity({\n      actual: currentBackupFileIdentity,\n      expected: rollback.backupFileIdentity,\n    })\n  ) {\n    throw new Error('The upload rollback backup no longer belongs to this operation.')\n  }\n\n  await linkFileWithoutOverwrite({\n    sourceFilePath: rollback.backupFilePath,\n    targetFilePath: rollback.filePath,\n  })\n}\n\nconst throwCollectedErrors = ({ errors }: { errors: unknown[] }): void => {\n  if (errors.length === 1) {\n    throw errors[0]\n  }\n\n  if (errors.length > 1) {\n    throw new AggregateError(errors, 'Multiple upload rollback tasks failed.')\n  }\n}\n"],"names":["randomUUID","constants","fs","path","getFileHandleIdentity","getFileIdentity","hasFileIdentity","hasRenameStableFileIdentity","linkFileWithoutOverwrite","stageUploadFileRollback","file","rollbacks","rollback","get","createUploadFileRollback","filePath","set","stagedFilePath","join","directoryPath","stagedFilePaths","add","publishUploadedFile","stagedFile","has","Error","precedingPublish","publishQueue","releasePublish","Promise","resolve","fileHandle","open","publicationState","quarantinedDestination","quarantineUploadDestination","hasExpectedDestination","expectedDestinationFileIdentity","undefined","hasMatchingDestination","actual","fileIdentity","expected","restoreQuarantinedUploadDestination","sourceFilePath","targetFilePath","error","restoreError","AggregateError","uploadedFileIdentity","close","cleanupUploadFileRollbacks","errors","values","rm","force","recursive","push","clear","throwCollectedErrors","rollbackUploadFiles","reverse","rollbackUploadFile","delete","originalFileIdentity","isRegularFile","dirname","mkdir","mode","Set","backupFilePath","copyFile","COPYFILE_EXCL","currentOriginalFileIdentity","backupFileIdentity","all","catch","quarantinedFilePath","rename","code","restoreBackupIfPresent","quarantinedFileIdentity","currentBackupFileIdentity","length"],"mappings":"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"}

package/dist/utilities/extractRelationshipID.d.ts

@@ -1,4 +0,0 @@
-export declare const extractRelationshipID: ({ relationship, }: {
-    relationship: unknown;
-}) => number | string | undefined;
-//# sourceMappingURL=extractRelationshipID.d.ts.map

package/dist/utilities/extractRelationshipID.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"extractRelationshipID.d.ts","sourceRoot":"","sources":["../../src/utilities/extractRelationshipID.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,qBAAqB,sBAE/B;IACD,YAAY,EAAE,OAAO,CAAA;CACtB,KAAG,MAAM,GAAG,MAAM,GAAG,SAcrB,CAAA"}

package/dist/utilities/extractRelationshipID.js

@@ -1,14 +0,0 @@
-export const extractRelationshipID = ({ relationship })=>{
-    if (typeof relationship === 'number' || typeof relationship === 'string') {
-        return relationship;
-    }
-    if (relationship && typeof relationship === 'object' && 'value' in relationship) {
-        const relationshipID = relationship.value;
-        if (typeof relationshipID === 'number' || typeof relationshipID === 'string') {
-            return relationshipID;
-        }
-    }
-    return undefined;
-};
-
-//# sourceMappingURL=extractRelationshipID.js.map

package/dist/utilities/extractRelationshipID.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/utilities/extractRelationshipID.ts"],"sourcesContent":["export const extractRelationshipID = ({\n  relationship,\n}: {\n  relationship: unknown\n}): number | string | undefined => {\n  if (typeof relationship === 'number' || typeof relationship === 'string') {\n    return relationship\n  }\n\n  if (relationship && typeof relationship === 'object' && 'value' in relationship) {\n    const relationshipID = relationship.value\n\n    if (typeof relationshipID === 'number' || typeof relationshipID === 'string') {\n      return relationshipID\n    }\n  }\n\n  return undefined\n}\n"],"names":["extractRelationshipID","relationship","relationshipID","value","undefined"],"mappings":"AAAA,OAAO,MAAMA,wBAAwB,CAAC,EACpCC,YAAY,EAGb;IACC,IAAI,OAAOA,iBAAiB,YAAY,OAAOA,iBAAiB,UAAU;QACxE,OAAOA;IACT;IAEA,IAAIA,gBAAgB,OAAOA,iBAAiB,YAAY,WAAWA,cAAc;QAC/E,MAAMC,iBAAiBD,aAAaE,KAAK;QAEzC,IAAI,OAAOD,mBAAmB,YAAY,OAAOA,mBAAmB,UAAU;YAC5E,OAAOA;QACT;IACF;IAEA,OAAOE;AACT,EAAC"}

package/dist/utilities/transactionCallbacks.d.ts

@@ -1,77 +0,0 @@
-import type { MarkRequired } from 'ts-essentials';
-import type { PayloadRequest } from '../types/index.js';
-type TransactionCallback = () => Promise<void>;
-type TransactionCallbackEntry = {
-    callback: TransactionCallback;
-    sequence: number;
-};
-type TransactionID = number | string;
-export type DeferredCleanupScope = {
-    callbacks: TransactionCallbackEntry[];
-    database: object;
-    parent: DeferredCleanupScope | null;
-    state: 'closed' | 'collecting' | 'flushing';
-    transactionID?: TransactionID;
-};
-export declare const deferredCleanupScopeContextKey = "_payloadDeferredCleanupScope";
-/** Creates a request context whose cleanup callbacks can be managed independently. */
-export declare const createIsolatedDeferredCleanupContext: ({ req, }: {
-    req: Partial<PayloadRequest>;
-}) => PayloadRequest['context'];
-export declare const hasActiveDeferredCleanupScope: ({ req }: {
-    req: Partial<PayloadRequest>;
-}) => boolean;
-/**
- * Creates an operation-owned cleanup queue. Successful nested scopes transfer their cleanup to a
- * parent for the same database and transaction. Root transaction scopes transfer their cleanup to
- * the transaction queue. Failed scopes can therefore discard only the cleanup they still own.
- */
-export declare const beginDeferredCleanupScope: ({ req, }: {
-    req: MarkRequired<Partial<PayloadRequest>, 'payload'>;
-}) => Promise<DeferredCleanupScope>;
-/** Reuses an operation scope when a low-level cleanup helper does not need its own savepoint. */
-export declare const beginDeferredCleanupScopeIfNeeded: ({ req, }: {
-    req: MarkRequired<Partial<PayloadRequest>, 'payload'>;
-}) => Promise<DeferredCleanupScope | null>;
-export declare const scheduleAfterTransactionCommit: ({ callback, req, }: {
-    callback: TransactionCallback;
-    req: MarkRequired<Partial<PayloadRequest>, 'payload'>;
-}) => Promise<void>;
-export declare const scheduleAfterTransactionRollback: ({ callback, req, }: {
-    callback: TransactionCallback;
-    req: MarkRequired<Partial<PayloadRequest>, 'payload'>;
-}) => Promise<void>;
-export declare const runTransactionCommitCallbacks: ({ req, transactionID, }: {
-    req: MarkRequired<Partial<PayloadRequest>, 'payload'>;
-    transactionID: TransactionID;
-}) => Promise<void>;
-export declare const clearTransactionCommitCallbacks: ({ req, transactionID, }: {
-    req: MarkRequired<Partial<PayloadRequest>, 'payload'>;
-    transactionID: TransactionID;
-}) => void;
-export declare const runTransactionRollbackCallbacks: ({ req, transactionID, }: {
-    req: MarkRequired<Partial<PayloadRequest>, 'payload'>;
-    transactionID: TransactionID;
-}) => Promise<void>;
-export declare const clearTransactionRollbackCallbacks: ({ req, transactionID, }: {
-    req: MarkRequired<Partial<PayloadRequest>, 'payload'>;
-    transactionID: TransactionID;
-}) => void;
-export declare const flushDeferredCleanupScope: ({ req, scope, }: {
-    req: MarkRequired<Partial<PayloadRequest>, 'payload'>;
-    scope: DeferredCleanupScope;
-}) => Promise<void>;
-/**
- * Flushes cleanup after an operation's database work has completed. A cleanup failure cannot undo
- * that write, so report it with the same contract used after a committed transaction.
- */
-export declare const flushDeferredCleanupScopeAfterOperation: ({ req, scope, }: {
-    req: MarkRequired<Partial<PayloadRequest>, 'payload'>;
-    scope: DeferredCleanupScope;
-}) => Promise<void>;
-export declare const clearDeferredCleanupScope: ({ req, scope, }: {
-    req: MarkRequired<Partial<PayloadRequest>, 'payload'>;
-    scope: DeferredCleanupScope;
-}) => void;
-export {};
-//# sourceMappingURL=transactionCallbacks.d.ts.map

package/dist/utilities/transactionCallbacks.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"transactionCallbacks.d.ts","sourceRoot":"","sources":["../../src/utilities/transactionCallbacks.ts"],"names":[],"mappings":"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"}