@humaan/payload-storage-imagekit 2.9.1 → 3.0.0-canary.1

package/dist/endpoints/createImageKitUploadInstructions.js

@@ -0,0 +1,117 @@
+import { buildUploadStoragePathData } from '@payloadcms/plugin-cloud-storage/utilities';
+import { randomUUID } from 'node:crypto';
+import { posix } from 'node:path';
+import { Forbidden } from 'payload';
+import { assertClientUploadAccess, assertClientUploadAllowed, createClientUploadReceipt, getOriginalFilename, getSafeFileName, incrementName } from 'payload/internal';
+import { getSanitizedUploadFilename } from 'payload/shared';
+import { createImageKitUploadToken } from '../imageKitUploadToken.js';
+/** ImageKit enforces these constraints before accepting any provider-direct bytes. */ export const getUploadChecks = ({ allowedMimeTypes, allowRestrictedFileTypes, filesize })=>{
+    const checks = [
+        `"file.size" = ${filesize}`
+    ];
+    const prefixes = allowedMimeTypes.map((mimeType)=>mimeType.replace('*', '')).filter((prefix)=>!/["\\]/.test(prefix));
+    if (prefixes.length && !prefixes.includes('')) {
+        checks.push(`(${prefixes.map((prefix)=>`"file.mime" : "${prefix}"`).join(' OR ')})`);
+    }
+    if (!allowRestrictedFileTypes) {
+        checks.push('"file.mime" NOT IN ["application/atom+xml", "application/mathml+xml", "application/rdf+xml", "application/rss+xml", "application/xhtml+xml", "application/xml", "application/xslt+xml", "image/svg+xml", "text/xml"]');
+    }
+    return checks.join(' AND ');
+};
+export const createImageKitUploadInstructions = ({ access = ({ req })=>Boolean(req.user), isPrivate, prefix, privateKey, publicKey })=>async ({ collectionSlug, docPrefix, filename, filesize, mimeType, overrideAccess, req })=>{
+        if (!overrideAccess) {
+            await assertClientUploadAccess({
+                collectionSlug,
+                req
+            });
+            if (!await access({
+                collectionSlug,
+                req
+            })) {
+                throw new Forbidden(req.t);
+            }
+        }
+        const collection = req.payload.collections[collectionSlug].config;
+        assertClientUploadAllowed({
+            collection,
+            filename,
+            mimeType
+        });
+        let safeFilename = await getSafeFileName({
+            collectionSlug,
+            desiredFilename: getSanitizedUploadFilename(filename).replace(/[^\w.-]/g, '_'),
+            req
+        });
+        // Without a transformer, v4 exposes the retained original as the current file.
+        // Reserve both names so repeated uploads cannot violate filename uniqueness.
+        while(await getSafeFileName({
+            collectionSlug,
+            desiredFilename: getOriginalFilename({
+                filename: safeFilename
+            }),
+            req
+        }) !== getOriginalFilename({
+            filename: safeFilename
+        })){
+            safeFilename = incrementName(safeFilename);
+        }
+        const originalFilename = getOriginalFilename({
+            filename: safeFilename
+        });
+        const objectKey = randomUUID();
+        const resolved = buildUploadStoragePathData({
+            collectionPrefix: prefix,
+            docPrefix: docPrefix ?? prefix,
+            filename: originalFilename
+        });
+        // The admin sends an empty docPrefix for new files; the resolved destination retains the collection fallback.
+        const filePrefix = posix.dirname(resolved.storageFilePath);
+        const storageFilePath = posix.join(filePrefix, objectKey, originalFilename);
+        const uploadReference = {
+            _objectKey: objectKey,
+            prefix: filePrefix,
+            signedReceipt: createClientUploadReceipt({
+                _objectKey: objectKey,
+                collectionSlug,
+                filename: safeFilename,
+                filePrefix,
+                req,
+                storageFilePath
+            })
+        };
+        const upload = typeof collection.upload === 'object' ? collection.upload : undefined;
+        const uploadPayload = {
+            checks: getUploadChecks({
+                allowedMimeTypes: upload?.mimeTypes ?? [],
+                allowRestrictedFileTypes: upload?.allowRestrictedFileTypes ?? false,
+                filesize
+            }),
+            fileName: originalFilename,
+            folder: `/${posix.dirname(storageFilePath)}`,
+            isPrivateFile: isPrivate ? 'true' : 'false',
+            overwriteFile: 'false',
+            tags: `payload-upload-${objectKey}`,
+            useUniqueFileName: 'false'
+        };
+        return {
+            name: 'imagekit',
+            type: 'dispatch',
+            data: {
+                token: createImageKitUploadToken({
+                    privateKey,
+                    publicKey,
+                    uploadPayload
+                }),
+                uploadPayload,
+                uploadReference
+            },
+            file: {
+                filename: safeFilename,
+                mimeType,
+                size: filesize,
+                uploadReference
+            }
+        };
+    };
+
+//# sourceMappingURL=createImageKitUploadInstructions.js.map

package/dist/endpoints/createImageKitUploadInstructions.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/endpoints/createImageKitUploadInstructions.ts"],"sourcesContent":["import type { GenerateUploadInstructions, UploadInstructionsAccess } from 'payload'\n\nimport { buildUploadStoragePathData } from '@payloadcms/plugin-cloud-storage/utilities'\nimport { randomUUID } from 'node:crypto'\nimport { posix } from 'node:path'\nimport { Forbidden } from 'payload'\nimport {\n  assertClientUploadAccess,\n  assertClientUploadAllowed,\n  createClientUploadReceipt,\n  getOriginalFilename,\n  getSafeFileName,\n  incrementName,\n} from 'payload/internal'\nimport { getSanitizedUploadFilename } from 'payload/shared'\n\nimport type { ImageKitUploadPayload } from '../clientUploads.js'\n\nimport { createImageKitUploadToken } from '../imageKitUploadToken.js'\n\n/** ImageKit enforces these constraints before accepting any provider-direct bytes. */\nexport const getUploadChecks = ({\n  allowedMimeTypes,\n  allowRestrictedFileTypes,\n  filesize,\n}: {\n  allowedMimeTypes: string[]\n  allowRestrictedFileTypes: boolean\n  filesize: number\n}): string => {\n  const checks = [`\"file.size\" = ${filesize}`]\n  const prefixes = allowedMimeTypes\n    .map((mimeType) => mimeType.replace('*', ''))\n    .filter((prefix) => !/[\"\\\\]/.test(prefix))\n\n  if (prefixes.length && !prefixes.includes('')) {\n    checks.push(`(${prefixes.map((prefix) => `\"file.mime\" : \"${prefix}\"`).join(' OR ')})`)\n  }\n  if (!allowRestrictedFileTypes) {\n    checks.push(\n      '\"file.mime\" NOT IN [\"application/atom+xml\", \"application/mathml+xml\", \"application/rdf+xml\", \"application/rss+xml\", \"application/xhtml+xml\", \"application/xml\", \"application/xslt+xml\", \"image/svg+xml\", \"text/xml\"]',\n    )\n  }\n  return checks.join(' AND ')\n}\n\nexport const createImageKitUploadInstructions =\n  ({\n    access = ({ req }) => Boolean(req.user),\n    isPrivate,\n    prefix,\n    privateKey,\n    publicKey,\n  }: {\n    access?: UploadInstructionsAccess\n    isPrivate: boolean\n    prefix: string\n    privateKey: string\n    publicKey: string\n  }): GenerateUploadInstructions =>\n  async ({ collectionSlug, docPrefix, filename, filesize, mimeType, overrideAccess, req }) => {\n    if (!overrideAccess) {\n      await assertClientUploadAccess({ collectionSlug, req })\n      if (!(await access({ collectionSlug, req }))) {\n        throw new Forbidden(req.t)\n      }\n    }\n    const collection = req.payload.collections[collectionSlug].config\n    assertClientUploadAllowed({ collection, filename, mimeType })\n    let safeFilename = await getSafeFileName({\n      collectionSlug,\n      desiredFilename: getSanitizedUploadFilename(filename).replace(/[^\\w.-]/g, '_'),\n      req,\n    })\n    // Without a transformer, v4 exposes the retained original as the current file.\n    // Reserve both names so repeated uploads cannot violate filename uniqueness.\n    while (\n      (await getSafeFileName({\n        collectionSlug,\n        desiredFilename: getOriginalFilename({ filename: safeFilename }),\n        req,\n      })) !== getOriginalFilename({ filename: safeFilename })\n    ) {\n      safeFilename = incrementName(safeFilename)\n    }\n    const originalFilename = getOriginalFilename({ filename: safeFilename })\n    const objectKey = randomUUID()\n    const resolved = buildUploadStoragePathData({\n      collectionPrefix: prefix,\n      docPrefix: docPrefix ?? prefix,\n      filename: originalFilename,\n    })\n    // The admin sends an empty docPrefix for new files; the resolved destination retains the collection fallback.\n    const filePrefix = posix.dirname(resolved.storageFilePath)\n    const storageFilePath = posix.join(filePrefix, objectKey, originalFilename)\n    const uploadReference = {\n      _objectKey: objectKey,\n      prefix: filePrefix,\n      signedReceipt: createClientUploadReceipt({\n        _objectKey: objectKey,\n        collectionSlug,\n        filename: safeFilename,\n        filePrefix,\n        req,\n        storageFilePath,\n      }),\n    }\n    const upload = typeof collection.upload === 'object' ? collection.upload : undefined\n    const uploadPayload: ImageKitUploadPayload = {\n      checks: getUploadChecks({\n        allowedMimeTypes: upload?.mimeTypes ?? [],\n        allowRestrictedFileTypes: upload?.allowRestrictedFileTypes ?? false,\n        filesize,\n      }),\n      fileName: originalFilename,\n      folder: `/${posix.dirname(storageFilePath)}`,\n      isPrivateFile: isPrivate ? 'true' : 'false',\n      overwriteFile: 'false',\n      tags: `payload-upload-${objectKey}`,\n      useUniqueFileName: 'false',\n    }\n    return {\n      name: 'imagekit',\n      type: 'dispatch',\n      data: {\n        token: createImageKitUploadToken({ privateKey, publicKey, uploadPayload }),\n        uploadPayload,\n        uploadReference,\n      },\n      file: { filename: safeFilename, mimeType, size: filesize, uploadReference },\n    }\n  }\n"],"names":["buildUploadStoragePathData","randomUUID","posix","Forbidden","assertClientUploadAccess","assertClientUploadAllowed","createClientUploadReceipt","getOriginalFilename","getSafeFileName","incrementName","getSanitizedUploadFilename","createImageKitUploadToken","getUploadChecks","allowedMimeTypes","allowRestrictedFileTypes","filesize","checks","prefixes","map","mimeType","replace","filter","prefix","test","length","includes","push","join","createImageKitUploadInstructions","access","req","Boolean","user","isPrivate","privateKey","publicKey","collectionSlug","docPrefix","filename","overrideAccess","t","collection","payload","collections","config","safeFilename","desiredFilename","originalFilename","objectKey","resolved","collectionPrefix","filePrefix","dirname","storageFilePath","uploadReference","_objectKey","signedReceipt","upload","undefined","uploadPayload","mimeTypes","fileName","folder","isPrivateFile","overwriteFile","tags","useUniqueFileName","name","type","data","token","file","size"],"mappings":"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"}

package/dist/imageKitFileStore.d.ts

@@ -0,0 +1,129 @@
+import type ImageKit from '@imagekit/nodejs';
+import type { PayloadRequest } from 'payload';
+/** Resolve new uploads by provider ID, without depending on ImageKit's eventual-consistency listing. */
+export declare const createImageKitFileStore: (client: ImageKit, urlEndpoint: string) => {
+    find: ({ key, req }: {
+        key: string;
+        req: PayloadRequest;
+    }) => Promise<{
+        name: string;
+        fileId: string;
+        size: number;
+        url: string;
+        AITags?: Array<ImageKit.Files.File.AITag> | null;
+        audioCodec?: string;
+        bitRate?: number;
+        createdAt?: string;
+        customCoordinates?: string | null;
+        customMetadata?: {
+            [key: string]: unknown;
+        };
+        description?: string;
+        duration?: number;
+        embeddedMetadata?: {
+            [key: string]: unknown;
+        };
+        filePath?: string;
+        fileType?: string;
+        hasAlpha?: boolean;
+        height?: number;
+        isPrivateFile?: boolean;
+        isPublished?: boolean;
+        mime?: string;
+        selectedFieldsSchema?: {
+            [key: string]: ImageKit.Files.File.SelectedFieldsSchema;
+        };
+        tags?: Array<string> | null;
+        thumbnail?: string;
+        type?: "file" | "file-version";
+        updatedAt?: string;
+        versionInfo?: ImageKit.Files.File.VersionInfo;
+        videoCodec?: string;
+        width?: number;
+    } | undefined>;
+    getByID: ({ fileId, key }: {
+        fileId: string;
+        key: string;
+    }) => Promise<{
+        name: string;
+        fileId: string;
+        size: number;
+        url: string;
+        AITags?: Array<ImageKit.Files.File.AITag> | null;
+        audioCodec?: string;
+        bitRate?: number;
+        createdAt?: string;
+        customCoordinates?: string | null;
+        customMetadata?: {
+            [key: string]: unknown;
+        };
+        description?: string;
+        duration?: number;
+        embeddedMetadata?: {
+            [key: string]: unknown;
+        };
+        filePath?: string;
+        fileType?: string;
+        hasAlpha?: boolean;
+        height?: number;
+        isPrivateFile?: boolean;
+        isPublished?: boolean;
+        mime?: string;
+        selectedFieldsSchema?: {
+            [key: string]: ImageKit.Files.File.SelectedFieldsSchema;
+        };
+        tags?: Array<string> | null;
+        thumbnail?: string;
+        type?: "file" | "file-version";
+        updatedAt?: string;
+        versionInfo?: ImageKit.Files.File.VersionInfo;
+        videoCodec?: string;
+        width?: number;
+    }>;
+    remember: ({ fileId, key, req, }: {
+        fileId: string;
+        key: string;
+        req: PayloadRequest;
+    }) => Promise<void>;
+    remove: ({ key, req }: {
+        key: string;
+        req: PayloadRequest;
+    }) => Promise<void>;
+    upload: ({ body, key, req, }: {
+        body: Parameters<ImageKit["files"]["upload"]>[0];
+        key: string;
+        req: PayloadRequest;
+    }) => Promise<{
+        fileId: string;
+        url: string;
+        AITags?: Array<ImageKit.Files.FileUploadResponse.AITag> | null;
+        audioCodec?: string;
+        bitRate?: number;
+        customCoordinates?: string | null;
+        customMetadata?: {
+            [key: string]: unknown;
+        };
+        description?: string;
+        duration?: number;
+        embeddedMetadata?: {
+            [key: string]: unknown;
+        };
+        extensionStatus?: ImageKit.Files.FileUploadResponse.ExtensionStatus;
+        filePath?: string;
+        fileType?: string;
+        height?: number;
+        isPrivateFile?: boolean;
+        isPublished?: boolean;
+        metadata?: ImageKit.Files.Metadata;
+        name?: string;
+        selectedFieldsSchema?: {
+            [key: string]: ImageKit.Files.FileUploadResponse.SelectedFieldsSchema;
+        };
+        size?: number;
+        tags?: Array<string> | null;
+        thumbnailUrl?: string;
+        versionInfo?: ImageKit.Files.FileUploadResponse.VersionInfo;
+        videoCodec?: string;
+        width?: number;
+    }>;
+};

package/dist/imageKitFileStore.js

@@ -0,0 +1,134 @@
+import { NotFoundError } from '@imagekit/nodejs';
+import { createHash } from 'node:crypto';
+import path from 'node:path';
+import { APIError } from 'payload';
+class FileLocationMismatch extends APIError {
+    constructor(){
+        super('ImageKit file does not match the authorized destination.', 400);
+    }
+}
+/** Resolve new uploads by provider ID, without depending on ImageKit's eventual-consistency listing. */ export const createImageKitFileStore = (client, urlEndpoint)=>{
+    const registryKey = (key)=>`imagekit:file:${createHash('sha256').update(JSON.stringify([
+            urlEndpoint,
+            key
+        ])).digest('hex')}`;
+    const getByID = async ({ fileId, key })=>{
+        const filePath = `/${key.replace(/^\/+/, '')}`;
+        const file = await client.files.get(fileId);
+        if (file.fileId !== fileId || typeof file.name !== 'string' || typeof file.filePath !== 'string' || typeof file.size !== 'number' || !Number.isSafeInteger(file.size) || file.size < 0 || !file.url) {
+            throw new APIError('ImageKit returned incomplete file metadata.', 502);
+        }
+        if (file.name !== path.posix.basename(filePath) || file.filePath !== filePath) {
+            throw new FileLocationMismatch();
+        }
+        return {
+            ...file,
+            name: file.name,
+            fileId,
+            size: file.size,
+            url: file.url
+        };
+    };
+    const remember = async ({ fileId, key, req })=>{
+        // This is a provider-object index, not an authorization or an upload session.
+        // Keep it for the object's lifetime (including retained versions), then remove it on delete.
+        await req.payload.kv.set(registryKey(key), fileId);
+    };
+    const upload = async ({ body, key, req })=>{
+        const uploaded = await client.files.upload(body);
+        try {
+            if (!uploaded.fileId || !uploaded.url) {
+                throw new APIError('ImageKit returned incomplete upload metadata.', 502);
+            }
+            await remember({
+                fileId: uploaded.fileId,
+                key,
+                req
+            });
+            return {
+                ...uploaded,
+                fileId: uploaded.fileId,
+                url: uploaded.url
+            };
+        } catch (error) {
+            // The provider write already succeeded, but the framework may not yet have registered
+            // its rollback action (notably for copies). Compensate by the returned ID, never a listing.
+            if (uploaded.fileId) {
+                try {
+                    await client.files.delete(uploaded.fileId);
+                    await req.payload.kv.delete(registryKey(key));
+                } catch (cleanupError) {
+                    req.payload.logger.error({
+                        err: cleanupError,
+                        msg: 'Failed to roll back an unregistered ImageKit upload.'
+                    });
+                }
+            }
+            throw error;
+        }
+    };
+    const find = async ({ key, req })=>{
+        const rememberedID = await req.payload.kv.get(registryKey(key));
+        if (rememberedID) {
+            try {
+                return await getByID({
+                    fileId: rememberedID,
+                    key
+                });
+            } catch (error) {
+                if (!(error instanceof NotFoundError) && !(error instanceof FileLocationMismatch)) {
+                    throw error;
+                }
+                // External deletes or moves can stale the index. Never delete the mismatched object;
+                // forget only its mapping and resolve the requested path normally.
+                await req.payload.kv.delete(registryKey(key));
+            }
+        }
+        // Existing installations and uploads started by older admin bundles have no registry entry.
+        const filePath = `/${key.replace(/^\/+/, '')}`;
+        const name = path.posix.basename(filePath);
+        for(let skip = 0;; skip += 100){
+            const assets = await client.assets.list({
+                type: 'file',
+                limit: 100,
+                path: `${path.posix.dirname(filePath)}/`,
+                skip
+            });
+            const found = assets.find((asset)=>asset.filePath === filePath && asset.name === name);
+            if (found?.fileId) {
+                return getByID({
+                    fileId: found.fileId,
+                    key
+                });
+            }
+            if (assets.length < 100) {
+                return undefined;
+            }
+        }
+    };
+    const remove = async ({ key, req })=>{
+        const file = await find({
+            key,
+            req
+        });
+        if (file) {
+            try {
+                await client.files.delete(file.fileId);
+            } catch (error) {
+                if (!(error instanceof NotFoundError)) {
+                    throw error;
+                }
+            }
+        }
+        await req.payload.kv.delete(registryKey(key));
+    };
+    return {
+        find,
+        getByID,
+        remember,
+        remove,
+        upload
+    };
+};
+
+//# sourceMappingURL=imageKitFileStore.js.map

package/dist/imageKitFileStore.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/imageKitFileStore.ts"],"sourcesContent":["import type ImageKit from '@imagekit/nodejs'\nimport type { PayloadRequest } from 'payload'\n\nimport { NotFoundError } from '@imagekit/nodejs'\nimport { createHash } from 'node:crypto'\nimport path from 'node:path'\nimport { APIError } from 'payload'\n\nclass FileLocationMismatch extends APIError {\n  constructor() {\n    super('ImageKit file does not match the authorized destination.', 400)\n  }\n}\n\n/** Resolve new uploads by provider ID, without depending on ImageKit's eventual-consistency listing. */\nexport const createImageKitFileStore = (client: ImageKit, urlEndpoint: string) => {\n  const registryKey = (key: string) =>\n    `imagekit:file:${createHash('sha256')\n      .update(JSON.stringify([urlEndpoint, key]))\n      .digest('hex')}`\n\n  const getByID = async ({ fileId, key }: { fileId: string; key: string }) => {\n    const filePath = `/${key.replace(/^\\/+/, '')}`\n    const file = await client.files.get(fileId)\n    if (\n      file.fileId !== fileId ||\n      typeof file.name !== 'string' ||\n      typeof file.filePath !== 'string' ||\n      typeof file.size !== 'number' ||\n      !Number.isSafeInteger(file.size) ||\n      file.size < 0 ||\n      !file.url\n    ) {\n      throw new APIError('ImageKit returned incomplete file metadata.', 502)\n    }\n    if (file.name !== path.posix.basename(filePath) || file.filePath !== filePath) {\n      throw new FileLocationMismatch()\n    }\n    return { ...file, name: file.name, fileId, size: file.size, url: file.url }\n  }\n\n  const remember = async ({\n    fileId,\n    key,\n    req,\n  }: {\n    fileId: string\n    key: string\n    req: PayloadRequest\n  }) => {\n    // This is a provider-object index, not an authorization or an upload session.\n    // Keep it for the object's lifetime (including retained versions), then remove it on delete.\n    await req.payload.kv.set(registryKey(key), fileId)\n  }\n\n  const upload = async ({\n    body,\n    key,\n    req,\n  }: {\n    body: Parameters<ImageKit['files']['upload']>[0]\n    key: string\n    req: PayloadRequest\n  }) => {\n    const uploaded = await client.files.upload(body)\n    try {\n      if (!uploaded.fileId || !uploaded.url) {\n        throw new APIError('ImageKit returned incomplete upload metadata.', 502)\n      }\n      await remember({ fileId: uploaded.fileId, key, req })\n      return { ...uploaded, fileId: uploaded.fileId, url: uploaded.url }\n    } catch (error) {\n      // The provider write already succeeded, but the framework may not yet have registered\n      // its rollback action (notably for copies). Compensate by the returned ID, never a listing.\n      if (uploaded.fileId) {\n        try {\n          await client.files.delete(uploaded.fileId)\n          await req.payload.kv.delete(registryKey(key))\n        } catch (cleanupError) {\n          req.payload.logger.error({\n            err: cleanupError,\n            msg: 'Failed to roll back an unregistered ImageKit upload.',\n          })\n        }\n      }\n      throw error\n    }\n  }\n\n  const find = async ({ key, req }: { key: string; req: PayloadRequest }) => {\n    const rememberedID = await req.payload.kv.get<string>(registryKey(key))\n    if (rememberedID) {\n      try {\n        return await getByID({ fileId: rememberedID, key })\n      } catch (error) {\n        if (!(error instanceof NotFoundError) && !(error instanceof FileLocationMismatch)) {\n          throw error\n        }\n        // External deletes or moves can stale the index. Never delete the mismatched object;\n        // forget only its mapping and resolve the requested path normally.\n        await req.payload.kv.delete(registryKey(key))\n      }\n    }\n    // Existing installations and uploads started by older admin bundles have no registry entry.\n    const filePath = `/${key.replace(/^\\/+/, '')}`\n    const name = path.posix.basename(filePath)\n    for (let skip = 0; ; skip += 100) {\n      const assets = await client.assets.list({\n        type: 'file',\n        limit: 100,\n        path: `${path.posix.dirname(filePath)}/`,\n        skip,\n      })\n      const found = assets.find((asset) => asset.filePath === filePath && asset.name === name)\n      if (found?.fileId) {\n        return getByID({ fileId: found.fileId, key })\n      }\n      if (assets.length < 100) {\n        return undefined\n      }\n    }\n  }\n\n  const remove = async ({ key, req }: { key: string; req: PayloadRequest }) => {\n    const file = await find({ key, req })\n    if (file) {\n      try {\n        await client.files.delete(file.fileId)\n      } catch (error) {\n        if (!(error instanceof NotFoundError)) {\n          throw error\n        }\n      }\n    }\n    await req.payload.kv.delete(registryKey(key))\n  }\n\n  return { find, getByID, remember, remove, upload }\n}\n"],"names":["NotFoundError","createHash","path","APIError","FileLocationMismatch","createImageKitFileStore","client","urlEndpoint","registryKey","key","update","JSON","stringify","digest","getByID","fileId","filePath","replace","file","files","get","name","size","Number","isSafeInteger","url","posix","basename","remember","req","payload","kv","set","upload","body","uploaded","error","delete","cleanupError","logger","err","msg","find","rememberedID","skip","assets","list","type","limit","dirname","found","asset","length","undefined","remove"],"mappings":"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"}

package/dist/index.d.ts

@@ -1,47 +1,25 @@
 import type { ClientUploadsConfig } from '@payloadcms/plugin-cloud-storage/types';
-import type { Config, UploadCollectionSlug } from 'payload';
+import type { StorageAdapter, UploadCollectionSlug } from 'payload';
 export type ImageKitCollectionOptions = {
-    /**
-     * Override Payload's native focal-point picker (`upload.focalPoint`) for this
-     * collection.
-     */
     focalPoint?: boolean;
-    /**
-     * Upload files in this collection as ImageKit private files (`isPrivateFile: true`)
-     * and deliver them only through short-lived signed URLs, behind Payload access control.
-     */
     private?: boolean;
 };
-type ImageKitCollectionConfig = ImageKitCollectionOptions | true;
-type ImageKitCollectionMap = Partial<Record<UploadCollectionSlug, ImageKitCollectionConfig>>;
 export type PayloadStorageImageKitConfig = {
-    alwaysInsertFields?: boolean;
     clientUploads?: ClientUploadsConfig;
-    collections: ImageKitCollectionMap;
+    collections: Partial<Record<UploadCollectionSlug, ImageKitCollectionOptions | true>>;
     disablePayloadAccessControl?: true;
     enabled?: boolean;
-    /**
-     * Broad default for Payload's native focal-point picker (`upload.focalPoint`)
-     * on every configured collection. Focal points are disabled by default for
-     * configured collections, so prefer collection-level `focalPoint: true` for
-     * image collections. A collection's own `upload.focalPoint` still takes
-     * precedence.
-     */
     focalPoint?: boolean;
     folder: string;
     privateKey: string;
     publicKey: string;
-    /**
-     * Expiry (in seconds) applied to signed URLs generated for private collections.
-     * Defaults to 900 (15 minutes). URLs are signed fresh on every request, so a short
-     * window is safe.
-     */
     signedUrlExpiresIn?: number;
     urlEndpoint: string;
 };
-export declare const imagekitStorage: (pluginOptions: PayloadStorageImageKitConfig) => (config: Config) => Config;
+/** Payload 4 storage capability. Register under config.storage, not config.plugins. */
+export declare const imagekitStorage: (options: PayloadStorageImageKitConfig) => StorageAdapter;
 export { migrateFolder } from './migrate.js';
 export type { MigrateFolderOptions, MigrationJobResult, MigrationLocation } from './migrate.js';
-export declare const payloadStorageImagekit: (pluginOptions: PayloadStorageImageKitConfig) => (config: Config) => Config;
-export declare const payloadStorageImageKit: (pluginOptions: PayloadStorageImageKitConfig) => (config: Config) => Config;
+export declare const payloadStorageImagekit: (options: PayloadStorageImageKitConfig) => StorageAdapter;
+export declare const payloadStorageImageKit: (options: PayloadStorageImageKitConfig) => StorageAdapter;
 export type PayloadStorageImagekitConfig = PayloadStorageImageKitConfig;