@webiny/sdk 6.0.0 → 6.1.0-beta.0

package/methods/fileManager/createFile.js

@@ -0,0 +1,168 @@
+import { Result } from "../../Result.js";
+import { getFileSize } from "./utils/fileTypeDetection.js";
+import { buildFieldsSelection } from "./buildFieldsSelection.js";
+/**
+ * Creates a new file in the file manager.
+ * If a file is provided, it will be uploaded to S3 first, then the record is created.
+ * If no file is provided, only the metadata record is created.
+ *
+ * @param config - SDK configuration
+ * @param fetchFn - Fetch function to use for HTTP requests
+ * @param params - Parameters for creating the file
+ * @param params.file - Optional: The actual file content to upload
+ * @param params.data - The file metadata
+ * @param params.onProgress - Optional: Progress callback
+ * @param params.multiPartThreshold - Optional: Threshold in MB for multi-part upload (default: 100)
+ * @param params.signal - Optional: AbortSignal for cancellation
+ * @returns Result containing the created file data or an error
+ */
+export async function createFile(config, fetchFn, params) {
+  const {
+    file,
+    data,
+    fields,
+    onProgress,
+    multiPartThreshold = 100,
+    signal
+  } = params;
+
+  // If no file provided, just create metadata record (existing behavior).
+  if (!file) {
+    return createFileRecord(config, fetchFn, data, fields);
+  }
+
+  // File upload flow.
+  try {
+    const fileSize = getFileSize(file);
+    const thresholdBytes = multiPartThreshold * 1024 * 1024;
+
+    // Ensure we have required metadata for upload.
+    if (!data.name || !data.type) {
+      return Result.fail(new Error("File name and type are required for upload"));
+    }
+
+    // Decide upload strategy based on file size.
+    if (fileSize < thresholdBytes) {
+      // Simple upload.
+      return await uploadSmallFile(config, fetchFn, file, data, fields, onProgress, signal);
+    } else {
+      // Multi-part upload.
+      return await uploadLargeFileWrapper(config, fetchFn, file, data, fields, onProgress, signal);
+    }
+  } catch (error) {
+    return Result.fail(error);
+  }
+}
+
+/**
+ * Uploads a small file using simple presigned POST.
+ */
+async function uploadSmallFile(config, fetchFn, file, data, fields, onProgress, signal) {
+  // 1. Get presigned POST payload.
+  const {
+    getPresignedPostPayload
+  } = await import("./getPresignedPostPayload.js");
+  const presignedResult = await getPresignedPostPayload(config, fetchFn, {
+    name: data.name,
+    type: data.type,
+    size: getFileSize(file),
+    key: data.key,
+    keyPrefix: data.keyPrefix
+  });
+  if (presignedResult.isFail()) {
+    return Result.fail(presignedResult.error);
+  }
+
+  // 2. Upload to S3.
+  const {
+    uploadToS3
+  } = await import("./utils/uploadToS3.js");
+  await uploadToS3(file, presignedResult.value.data, {
+    onProgress,
+    signal
+  });
+
+  // 3. Create file record with S3 key from presigned response.
+  const fileMetadata = {
+    ...data,
+    id: presignedResult.value.file.id,
+    key: presignedResult.value.file.key,
+    size: presignedResult.value.file.size
+  };
+  return createFileRecord(config, fetchFn, fileMetadata, fields);
+}
+
+/**
+ * Uploads a large file using multi-part upload.
+ */
+async function uploadLargeFileWrapper(config, fetchFn, file, data, fields, onProgress, signal) {
+  try {
+    const {
+      uploadLargeFile
+    } = await import("./utils/uploadLargeFile.js");
+    const uploadedFile = await uploadLargeFile(file, {
+      name: data.name,
+      type: data.type,
+      size: getFileSize(file),
+      key: data.key,
+      keyPrefix: data.keyPrefix
+    }, config, fetchFn, {
+      onProgress,
+      signal,
+      chunkSize: 50,
+      parallelUploads: 5
+    });
+
+    // Create file record with uploaded metadata.
+    const fileMetadata = {
+      ...data,
+      id: uploadedFile.id,
+      key: uploadedFile.key,
+      size: uploadedFile.size
+    };
+    return createFileRecord(config, fetchFn, fileMetadata, fields);
+  } catch (error) {
+    return Result.fail(error);
+  }
+}
+
+/**
+ * Creates a file record via GraphQL (metadata only).
+ */
+async function createFileRecord(config, fetchFn, data, fields) {
+  const {
+    executeGraphQL
+  } = await import("../executeGraphQL.js");
+  const fieldsSelection = buildFieldsSelection(fields);
+  const query = `
+        mutation CreateFile($data: FmFileCreateInput!) {
+            fileManager {
+                createFile(data: $data) {
+                    data {
+${fieldsSelection}
+                    }
+                    error {
+                        message
+                        code
+                    }
+                }
+            }
+        }
+    `;
+  const result = await executeGraphQL(config, fetchFn, query, {
+    data
+  });
+  if (result.isFail()) {
+    return Result.fail(result.error);
+  }
+  const responseData = result.value;
+  if (responseData.fileManager.createFile.error) {
+    const {
+      GraphQLError
+    } = await import("../../errors.js");
+    return Result.fail(new GraphQLError(responseData.fileManager.createFile.error.message, responseData.fileManager.createFile.error.code));
+  }
+  return Result.ok(responseData.fileManager.createFile.data);
+}
+
+//# sourceMappingURL=createFile.js.map

package/methods/fileManager/createFile.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["Result","getFileSize","buildFieldsSelection","createFile","config","fetchFn","params","file","data","fields","onProgress","multiPartThreshold","signal","createFileRecord","fileSize","thresholdBytes","name","type","fail","Error","uploadSmallFile","uploadLargeFileWrapper","error","getPresignedPostPayload","presignedResult","size","key","keyPrefix","isFail","uploadToS3","value","fileMetadata","id","uploadLargeFile","uploadedFile","chunkSize","parallelUploads","executeGraphQL","fieldsSelection","query","result","responseData","fileManager","GraphQLError","message","code","ok"],"sources":["createFile.ts"],"sourcesContent":["import type { WebinyConfig } from \"../../types.js\";\nimport { Result } from \"../../Result.js\";\nimport type { HttpError, GraphQLError, NetworkError } from \"../../errors.js\";\nimport type { FmFile, FmIdentity, FmLocationInput, UploadProgress } from \"./fileManagerTypes.js\";\nimport { getFileSize } from \"./utils/fileTypeDetection.js\";\nimport { buildFieldsSelection } from \"./buildFieldsSelection.js\";\n\nexport interface CreateFileData {\n    id?: string;\n    createdOn?: Date | string;\n    modifiedOn?: Date | string;\n    savedOn?: Date | string;\n    createdBy?: FmIdentity;\n    modifiedBy?: FmIdentity;\n    savedBy?: FmIdentity;\n    location?: FmLocationInput;\n    name?: string;\n    key?: string;\n    keyPrefix?: string;\n    type?: string;\n    size?: number;\n    tags?: string[];\n    [key: string]: any;\n}\n\nexport interface CreateFileParams {\n    file?: Buffer | Blob | File;\n    data: CreateFileData;\n    fields: string[];\n    onProgress?: (progress: UploadProgress) => void;\n    multiPartThreshold?: number;\n    signal?: AbortSignal;\n}\n\n/**\n * Creates a new file in the file manager.\n * If a file is provided, it will be uploaded to S3 first, then the record is created.\n * If no file is provided, only the metadata record is created.\n *\n * @param config - SDK configuration\n * @param fetchFn - Fetch function to use for HTTP requests\n * @param params - Parameters for creating the file\n * @param params.file - Optional: The actual file content to upload\n * @param params.data - The file metadata\n * @param params.onProgress - Optional: Progress callback\n * @param params.multiPartThreshold - Optional: Threshold in MB for multi-part upload (default: 100)\n * @param params.signal - Optional: AbortSignal for cancellation\n * @returns Result containing the created file data or an error\n */\nexport async function createFile(\n    config: WebinyConfig,\n    fetchFn: typeof fetch,\n    params: CreateFileParams\n): Promise<Result<FmFile, HttpError | GraphQLError | NetworkError>> {\n    const { file, data, fields, onProgress, multiPartThreshold = 100, signal } = params;\n\n    // If no file provided, just create metadata record (existing behavior).\n    if (!file) {\n        return createFileRecord(config, fetchFn, data, fields);\n    }\n\n    // File upload flow.\n    try {\n        const fileSize = getFileSize(file);\n        const thresholdBytes = multiPartThreshold * 1024 * 1024;\n\n        // Ensure we have required metadata for upload.\n        if (!data.name || !data.type) {\n            return Result.fail(new Error(\"File name and type are required for upload\") as any);\n        }\n\n        // Decide upload strategy based on file size.\n        if (fileSize < thresholdBytes) {\n            // Simple upload.\n            return await uploadSmallFile(config, fetchFn, file, data, fields, onProgress, signal);\n        } else {\n            // Multi-part upload.\n            return await uploadLargeFileWrapper(\n                config,\n                fetchFn,\n                file,\n                data,\n                fields,\n                onProgress,\n                signal\n            );\n        }\n    } catch (error) {\n        return Result.fail(error as any);\n    }\n}\n\n/**\n * Uploads a small file using simple presigned POST.\n */\nasync function uploadSmallFile(\n    config: WebinyConfig,\n    fetchFn: typeof fetch,\n    file: Buffer | Blob | File,\n    data: CreateFileData,\n    fields: string[],\n    onProgress?: (progress: UploadProgress) => void,\n    signal?: AbortSignal\n): Promise<Result<FmFile, HttpError | GraphQLError | NetworkError>> {\n    // 1. Get presigned POST payload.\n    const { getPresignedPostPayload } = await import(\"./getPresignedPostPayload.js\");\n    const presignedResult = await getPresignedPostPayload(config, fetchFn, {\n        name: data.name!,\n        type: data.type!,\n        size: getFileSize(file),\n        key: data.key,\n        keyPrefix: data.keyPrefix\n    });\n\n    if (presignedResult.isFail()) {\n        return Result.fail(presignedResult.error);\n    }\n\n    // 2. Upload to S3.\n    const { uploadToS3 } = await import(\"./utils/uploadToS3.js\");\n    await uploadToS3(file, presignedResult.value.data, { onProgress, signal });\n\n    // 3. Create file record with S3 key from presigned response.\n    const fileMetadata: CreateFileData = {\n        ...data,\n        id: presignedResult.value.file.id,\n        key: presignedResult.value.file.key,\n        size: presignedResult.value.file.size\n    };\n\n    return createFileRecord(config, fetchFn, fileMetadata, fields);\n}\n\n/**\n * Uploads a large file using multi-part upload.\n */\nasync function uploadLargeFileWrapper(\n    config: WebinyConfig,\n    fetchFn: typeof fetch,\n    file: Buffer | Blob | File,\n    data: CreateFileData,\n    fields: string[],\n    onProgress?: (progress: UploadProgress) => void,\n    signal?: AbortSignal\n): Promise<Result<FmFile, HttpError | GraphQLError | NetworkError>> {\n    try {\n        const { uploadLargeFile } = await import(\"./utils/uploadLargeFile.js\");\n        const uploadedFile = await uploadLargeFile(\n            file,\n            {\n                name: data.name!,\n                type: data.type!,\n                size: getFileSize(file),\n                key: data.key,\n                keyPrefix: data.keyPrefix\n            },\n            config,\n            fetchFn,\n            { onProgress, signal, chunkSize: 50, parallelUploads: 5 }\n        );\n\n        // Create file record with uploaded metadata.\n        const fileMetadata: CreateFileData = {\n            ...data,\n            id: uploadedFile.id,\n            key: uploadedFile.key,\n            size: uploadedFile.size\n        };\n\n        return createFileRecord(config, fetchFn, fileMetadata, fields);\n    } catch (error) {\n        return Result.fail(error as any);\n    }\n}\n\n/**\n * Creates a file record via GraphQL (metadata only).\n */\nasync function createFileRecord(\n    config: WebinyConfig,\n    fetchFn: typeof fetch,\n    data: CreateFileData,\n    fields: string[]\n): Promise<Result<FmFile, HttpError | GraphQLError | NetworkError>> {\n    const { executeGraphQL } = await import(\"../executeGraphQL.js\");\n\n    const fieldsSelection = buildFieldsSelection(fields);\n\n    const query = `\n        mutation CreateFile($data: FmFileCreateInput!) {\n            fileManager {\n                createFile(data: $data) {\n                    data {\n${fieldsSelection}\n                    }\n                    error {\n                        message\n                        code\n                    }\n                }\n            }\n        }\n    `;\n\n    const result = await executeGraphQL(config, fetchFn, query, { data });\n\n    if (result.isFail()) {\n        return Result.fail(result.error);\n    }\n\n    const responseData = result.value;\n\n    if (responseData.fileManager.createFile.error) {\n        const { GraphQLError } = await import(\"../../errors.js\");\n        return Result.fail(\n            new GraphQLError(\n                responseData.fileManager.createFile.error.message,\n                responseData.fileManager.createFile.error.code\n            )\n        );\n    }\n\n    return Result.ok(responseData.fileManager.createFile.data);\n}\n"],"mappings":"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","ignoreList":[]}

package/methods/fileManager/createFiles.d.ts

@@ -0,0 +1,40 @@
+import type { WebinyConfig } from "../../types.js";
+import { Result } from "../../Result.js";
+import type { HttpError, GraphQLError, NetworkError } from "../../errors.js";
+import type { FmFile, UploadProgress, BatchUploadStrategy } from "./fileManagerTypes.js";
+import type { CreateFileData } from "./createFile.js";
+export interface CreateFilesParams {
+    files: Array<{
+        file?: Buffer | Blob | File;
+        data: CreateFileData;
+        fields: string[];
+        onProgress?: (progress: UploadProgress) => void;
+    }>;
+    multiPartThreshold?: number;
+    concurrency?: number;
+    strategy?: BatchUploadStrategy;
+    signal?: AbortSignal;
+}
+export interface CreateFilesResult {
+    successful: FmFile[];
+    failed: Array<{
+        data: CreateFileData;
+        error: Error;
+    }>;
+}
+/**
+ * Creates multiple files in the file manager.
+ * If files are provided, they will be uploaded to S3 first, then records are created.
+ * If no files are provided, only metadata records are created.
+ *
+ * @param config - SDK configuration
+ * @param fetchFn - Fetch function to use for HTTP requests
+ * @param params - Parameters for creating the files
+ * @param params.files - Array of files with their data
+ * @param params.multiPartThreshold - Optional: Threshold in MB for multi-part upload (default: 100)
+ * @param params.concurrency - Optional: Number of concurrent uploads (default: 5)
+ * @param params.strategy - Optional: Batch upload strategy (default: FAIL_FAST)
+ * @param params.signal - Optional: AbortSignal for cancellation
+ * @returns Result containing the created files or an error
+ */
+export declare function createFiles(config: WebinyConfig, fetchFn: typeof fetch, params: CreateFilesParams): Promise<Result<CreateFilesResult, HttpError | GraphQLError | NetworkError>>;

package/methods/fileManager/createFiles.js

@@ -0,0 +1,83 @@
+import { Result } from "../../Result.js";
+/**
+ * Creates multiple files in the file manager.
+ * If files are provided, they will be uploaded to S3 first, then records are created.
+ * If no files are provided, only metadata records are created.
+ *
+ * @param config - SDK configuration
+ * @param fetchFn - Fetch function to use for HTTP requests
+ * @param params - Parameters for creating the files
+ * @param params.files - Array of files with their data
+ * @param params.multiPartThreshold - Optional: Threshold in MB for multi-part upload (default: 100)
+ * @param params.concurrency - Optional: Number of concurrent uploads (default: 5)
+ * @param params.strategy - Optional: Batch upload strategy (default: FAIL_FAST)
+ * @param params.signal - Optional: AbortSignal for cancellation
+ * @returns Result containing the created files or an error
+ */
+export async function createFiles(config, fetchFn, params) {
+  const {
+    files,
+    multiPartThreshold = 100,
+    concurrency = 5,
+    strategy = "fail-fast",
+    signal
+  } = params;
+  const successful = [];
+  const failed = [];
+
+  // Use p-map for controlled concurrency.
+  const pMap = (await import("p-map")).default;
+  try {
+    await pMap(files, async fileItem => {
+      try {
+        // Check abort signal.
+        if (signal?.aborted) {
+          throw new Error("Upload aborted");
+        }
+
+        // Upload single file.
+        const {
+          createFile
+        } = await import("./createFile.js");
+        const result = await createFile(config, fetchFn, {
+          file: fileItem.file,
+          data: fileItem.data,
+          fields: fileItem.fields,
+          onProgress: fileItem.onProgress,
+          multiPartThreshold,
+          signal
+        });
+        if (result.isOk()) {
+          successful.push(result.value);
+        } else {
+          if (strategy === "fail-fast") {
+            throw result.error;
+          }
+          failed.push({
+            data: fileItem.data,
+            error: result.error
+          });
+        }
+      } catch (error) {
+        if (strategy === "fail-fast") {
+          throw error;
+        }
+        failed.push({
+          data: fileItem.data,
+          error: error
+        });
+      }
+    }, {
+      concurrency
+    });
+    return Result.ok({
+      successful,
+      failed
+    });
+  } catch (error) {
+    // Fail-fast: Return error immediately.
+    return Result.fail(error);
+  }
+}
+
+//# sourceMappingURL=createFiles.js.map

package/methods/fileManager/createFiles.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["Result","createFiles","config","fetchFn","params","files","multiPartThreshold","concurrency","strategy","signal","successful","failed","pMap","default","fileItem","aborted","Error","createFile","result","file","data","fields","onProgress","isOk","push","value","error","ok","fail"],"sources":["createFiles.ts"],"sourcesContent":["import type { WebinyConfig } from \"../../types.js\";\nimport { Result } from \"../../Result.js\";\nimport type { HttpError, GraphQLError, NetworkError } from \"../../errors.js\";\nimport type { FmFile, UploadProgress, BatchUploadStrategy } from \"./fileManagerTypes.js\";\nimport type { CreateFileData } from \"./createFile.js\";\n\nexport interface CreateFilesParams {\n    files: Array<{\n        file?: Buffer | Blob | File;\n        data: CreateFileData;\n        fields: string[];\n        onProgress?: (progress: UploadProgress) => void;\n    }>;\n    multiPartThreshold?: number;\n    concurrency?: number;\n    strategy?: BatchUploadStrategy;\n    signal?: AbortSignal;\n}\n\nexport interface CreateFilesResult {\n    successful: FmFile[];\n    failed: Array<{\n        data: CreateFileData;\n        error: Error;\n    }>;\n}\n\n/**\n * Creates multiple files in the file manager.\n * If files are provided, they will be uploaded to S3 first, then records are created.\n * If no files are provided, only metadata records are created.\n *\n * @param config - SDK configuration\n * @param fetchFn - Fetch function to use for HTTP requests\n * @param params - Parameters for creating the files\n * @param params.files - Array of files with their data\n * @param params.multiPartThreshold - Optional: Threshold in MB for multi-part upload (default: 100)\n * @param params.concurrency - Optional: Number of concurrent uploads (default: 5)\n * @param params.strategy - Optional: Batch upload strategy (default: FAIL_FAST)\n * @param params.signal - Optional: AbortSignal for cancellation\n * @returns Result containing the created files or an error\n */\nexport async function createFiles(\n    config: WebinyConfig,\n    fetchFn: typeof fetch,\n    params: CreateFilesParams\n): Promise<Result<CreateFilesResult, HttpError | GraphQLError | NetworkError>> {\n    const {\n        files,\n        multiPartThreshold = 100,\n        concurrency = 5,\n        strategy = \"fail-fast\" as BatchUploadStrategy,\n        signal\n    } = params;\n\n    const successful: FmFile[] = [];\n    const failed: Array<{ data: CreateFileData; error: Error }> = [];\n\n    // Use p-map for controlled concurrency.\n    const pMap = (await import(\"p-map\")).default;\n\n    try {\n        await pMap(\n            files,\n            async fileItem => {\n                try {\n                    // Check abort signal.\n                    if (signal?.aborted) {\n                        throw new Error(\"Upload aborted\");\n                    }\n\n                    // Upload single file.\n                    const { createFile } = await import(\"./createFile.js\");\n                    const result = await createFile(config, fetchFn, {\n                        file: fileItem.file,\n                        data: fileItem.data,\n                        fields: fileItem.fields,\n                        onProgress: fileItem.onProgress,\n                        multiPartThreshold,\n                        signal\n                    });\n\n                    if (result.isOk()) {\n                        successful.push(result.value);\n                    } else {\n                        if (strategy === \"fail-fast\") {\n                            throw result.error;\n                        }\n                        failed.push({ data: fileItem.data, error: result.error as Error });\n                    }\n                } catch (error) {\n                    if (strategy === \"fail-fast\") {\n                        throw error;\n                    }\n                    failed.push({ data: fileItem.data, error: error as Error });\n                }\n            },\n            { concurrency }\n        );\n\n        return Result.ok({ successful, failed });\n    } catch (error) {\n        // Fail-fast: Return error immediately.\n        return Result.fail(error as any);\n    }\n}\n"],"mappings":"AACA,SAASA,MAAM;AA0Bf;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,eAAeC,WAAWA,CAC7BC,MAAoB,EACpBC,OAAqB,EACrBC,MAAyB,EACkD;EAC3E,MAAM;IACFC,KAAK;IACLC,kBAAkB,GAAG,GAAG;IACxBC,WAAW,GAAG,CAAC;IACfC,QAAQ,GAAG,WAAkC;IAC7CC;EACJ,CAAC,GAAGL,MAAM;EAEV,MAAMM,UAAoB,GAAG,EAAE;EAC/B,MAAMC,MAAqD,GAAG,EAAE;;EAEhE;EACA,MAAMC,IAAI,GAAG,CAAC,MAAM,MAAM,CAAC,OAAO,CAAC,EAAEC,OAAO;EAE5C,IAAI;IACA,MAAMD,IAAI,CACNP,KAAK,EACL,MAAMS,QAAQ,IAAI;MACd,IAAI;QACA;QACA,IAAIL,MAAM,EAAEM,OAAO,EAAE;UACjB,MAAM,IAAIC,KAAK,CAAC,gBAAgB,CAAC;QACrC;;QAEA;QACA,MAAM;UAAEC;QAAW,CAAC,GAAG,MAAM,MAAM,kBAAkB,CAAC;QACtD,MAAMC,MAAM,GAAG,MAAMD,UAAU,CAACf,MAAM,EAAEC,OAAO,EAAE;UAC7CgB,IAAI,EAAEL,QAAQ,CAACK,IAAI;UACnBC,IAAI,EAAEN,QAAQ,CAACM,IAAI;UACnBC,MAAM,EAAEP,QAAQ,CAACO,MAAM;UACvBC,UAAU,EAAER,QAAQ,CAACQ,UAAU;UAC/BhB,kBAAkB;UAClBG;QACJ,CAAC,CAAC;QAEF,IAAIS,MAAM,CAACK,IAAI,CAAC,CAAC,EAAE;UACfb,UAAU,CAACc,IAAI,CAACN,MAAM,CAACO,KAAK,CAAC;QACjC,CAAC,MAAM;UACH,IAAIjB,QAAQ,KAAK,WAAW,EAAE;YAC1B,MAAMU,MAAM,CAACQ,KAAK;UACtB;UACAf,MAAM,CAACa,IAAI,CAAC;YAAEJ,IAAI,EAAEN,QAAQ,CAACM,IAAI;YAAEM,KAAK,EAAER,MAAM,CAACQ;UAAe,CAAC,CAAC;QACtE;MACJ,CAAC,CAAC,OAAOA,KAAK,EAAE;QACZ,IAAIlB,QAAQ,KAAK,WAAW,EAAE;UAC1B,MAAMkB,KAAK;QACf;QACAf,MAAM,CAACa,IAAI,CAAC;UAAEJ,IAAI,EAAEN,QAAQ,CAACM,IAAI;UAAEM,KAAK,EAAEA;QAAe,CAAC,CAAC;MAC/D;IACJ,CAAC,EACD;MAAEnB;IAAY,CAClB,CAAC;IAED,OAAOP,MAAM,CAAC2B,EAAE,CAAC;MAAEjB,UAAU;MAAEC;IAAO,CAAC,CAAC;EAC5C,CAAC,CAAC,OAAOe,KAAK,EAAE;IACZ;IACA,OAAO1B,MAAM,CAAC4B,IAAI,CAACF,KAAY,CAAC;EACpC;AACJ","ignoreList":[]}

package/methods/fileManager/createMultiPartUpload.d.ts

@@ -0,0 +1,38 @@
+import type { WebinyConfig } from "../../types.js";
+import { Result } from "../../Result.js";
+import type { HttpError, GraphQLError, NetworkError } from "../../errors.js";
+export interface CreateMultiPartUploadParams {
+    data: {
+        name: string;
+        type: string;
+        size: number;
+        key?: string;
+        keyPrefix?: string;
+    };
+    numberOfParts: number;
+}
+export interface MultiPartUploadResponse {
+    uploadId: string;
+    file: {
+        id: string;
+        name: string;
+        type: string;
+        size: number;
+        key: string;
+    };
+    parts: Array<{
+        partNumber: number;
+        url: string;
+    }>;
+}
+/**
+ * Creates a multi-part upload for a large file.
+ *
+ * @param config - SDK configuration
+ * @param fetchFn - Fetch function to use for HTTP requests
+ * @param params - Parameters for creating the multi-part upload
+ * @param params.data - File metadata
+ * @param params.numberOfParts - Number of parts to split the file into
+ * @returns Result containing the multi-part upload data or an error
+ */
+export declare function createMultiPartUpload(config: WebinyConfig, fetchFn: typeof fetch, params: CreateMultiPartUploadParams): Promise<Result<MultiPartUploadResponse, HttpError | GraphQLError | NetworkError>>;

package/methods/fileManager/createMultiPartUpload.js

@@ -0,0 +1,63 @@
+import { Result } from "../../Result.js";
+/**
+ * Creates a multi-part upload for a large file.
+ *
+ * @param config - SDK configuration
+ * @param fetchFn - Fetch function to use for HTTP requests
+ * @param params - Parameters for creating the multi-part upload
+ * @param params.data - File metadata
+ * @param params.numberOfParts - Number of parts to split the file into
+ * @returns Result containing the multi-part upload data or an error
+ */
+export async function createMultiPartUpload(config, fetchFn, params) {
+  const {
+    data,
+    numberOfParts
+  } = params;
+  const {
+    executeGraphQL
+  } = await import("../executeGraphQL.js");
+  const query = `
+        mutation CreateMultiPartUpload($data: PreSignedPostPayloadInput!, $numberOfParts: Number!) {
+            fileManager {
+                createMultiPartUpload(data: $data, numberOfParts: $numberOfParts) {
+                    data {
+                        uploadId
+                        file {
+                            id
+                            name
+                            type
+                            size
+                            key
+                        }
+                        parts {
+                            partNumber
+                            url
+                        }
+                    }
+                    error {
+                        message
+                        code
+                    }
+                }
+            }
+        }
+    `;
+  const result = await executeGraphQL(config, fetchFn, query, {
+    data,
+    numberOfParts
+  });
+  if (result.isFail()) {
+    return Result.fail(result.error);
+  }
+  const responseData = result.value;
+  if (responseData.fileManager.createMultiPartUpload.error) {
+    const {
+      GraphQLError
+    } = await import("../../errors.js");
+    return Result.fail(new GraphQLError(responseData.fileManager.createMultiPartUpload.error.message, responseData.fileManager.createMultiPartUpload.error.code));
+  }
+  return Result.ok(responseData.fileManager.createMultiPartUpload.data);
+}
+
+//# sourceMappingURL=createMultiPartUpload.js.map

package/methods/fileManager/createMultiPartUpload.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["Result","createMultiPartUpload","config","fetchFn","params","data","numberOfParts","executeGraphQL","query","result","isFail","fail","error","responseData","value","fileManager","GraphQLError","message","code","ok"],"sources":["createMultiPartUpload.ts"],"sourcesContent":["import type { WebinyConfig } from \"../../types.js\";\nimport { Result } from \"../../Result.js\";\nimport type { HttpError, GraphQLError, NetworkError } from \"../../errors.js\";\n\nexport interface CreateMultiPartUploadParams {\n    data: {\n        name: string;\n        type: string;\n        size: number;\n        key?: string;\n        keyPrefix?: string;\n    };\n    numberOfParts: number;\n}\n\nexport interface MultiPartUploadResponse {\n    uploadId: string;\n    file: {\n        id: string;\n        name: string;\n        type: string;\n        size: number;\n        key: string;\n    };\n    parts: Array<{\n        partNumber: number;\n        url: string;\n    }>;\n}\n\n/**\n * Creates a multi-part upload for a large file.\n *\n * @param config - SDK configuration\n * @param fetchFn - Fetch function to use for HTTP requests\n * @param params - Parameters for creating the multi-part upload\n * @param params.data - File metadata\n * @param params.numberOfParts - Number of parts to split the file into\n * @returns Result containing the multi-part upload data or an error\n */\nexport async function createMultiPartUpload(\n    config: WebinyConfig,\n    fetchFn: typeof fetch,\n    params: CreateMultiPartUploadParams\n): Promise<Result<MultiPartUploadResponse, HttpError | GraphQLError | NetworkError>> {\n    const { data, numberOfParts } = params;\n\n    const { executeGraphQL } = await import(\"../executeGraphQL.js\");\n\n    const query = `\n        mutation CreateMultiPartUpload($data: PreSignedPostPayloadInput!, $numberOfParts: Number!) {\n            fileManager {\n                createMultiPartUpload(data: $data, numberOfParts: $numberOfParts) {\n                    data {\n                        uploadId\n                        file {\n                            id\n                            name\n                            type\n                            size\n                            key\n                        }\n                        parts {\n                            partNumber\n                            url\n                        }\n                    }\n                    error {\n                        message\n                        code\n                    }\n                }\n            }\n        }\n    `;\n\n    const result = await executeGraphQL(config, fetchFn, query, { data, numberOfParts });\n\n    if (result.isFail()) {\n        return Result.fail(result.error);\n    }\n\n    const responseData = result.value;\n\n    if (responseData.fileManager.createMultiPartUpload.error) {\n        const { GraphQLError } = await import(\"../../errors.js\");\n        return Result.fail(\n            new GraphQLError(\n                responseData.fileManager.createMultiPartUpload.error.message,\n                responseData.fileManager.createMultiPartUpload.error.code\n            )\n        );\n    }\n\n    return Result.ok(responseData.fileManager.createMultiPartUpload.data);\n}\n"],"mappings":"AACA,SAASA,MAAM;AA6Bf;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,eAAeC,qBAAqBA,CACvCC,MAAoB,EACpBC,OAAqB,EACrBC,MAAmC,EAC8C;EACjF,MAAM;IAAEC,IAAI;IAAEC;EAAc,CAAC,GAAGF,MAAM;EAEtC,MAAM;IAAEG;EAAe,CAAC,GAAG,MAAM,MAAM,uBAAuB,CAAC;EAE/D,MAAMC,KAAK,GAAG;AAClB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;EAED,MAAMC,MAAM,GAAG,MAAMF,cAAc,CAACL,MAAM,EAAEC,OAAO,EAAEK,KAAK,EAAE;IAAEH,IAAI;IAAEC;EAAc,CAAC,CAAC;EAEpF,IAAIG,MAAM,CAACC,MAAM,CAAC,CAAC,EAAE;IACjB,OAAOV,MAAM,CAACW,IAAI,CAACF,MAAM,CAACG,KAAK,CAAC;EACpC;EAEA,MAAMC,YAAY,GAAGJ,MAAM,CAACK,KAAK;EAEjC,IAAID,YAAY,CAACE,WAAW,CAACd,qBAAqB,CAACW,KAAK,EAAE;IACtD,MAAM;MAAEI;IAAa,CAAC,GAAG,MAAM,MAAM,kBAAkB,CAAC;IACxD,OAAOhB,MAAM,CAACW,IAAI,CACd,IAAIK,YAAY,CACZH,YAAY,CAACE,WAAW,CAACd,qBAAqB,CAACW,KAAK,CAACK,OAAO,EAC5DJ,YAAY,CAACE,WAAW,CAACd,qBAAqB,CAACW,KAAK,CAACM,IACzD,CACJ,CAAC;EACL;EAEA,OAAOlB,MAAM,CAACmB,EAAE,CAACN,YAAY,CAACE,WAAW,CAACd,qBAAqB,CAACI,IAAI,CAAC;AACzE","ignoreList":[]}

package/methods/fileManager/deleteFile.d.ts

@@ -0,0 +1,16 @@
+import type { WebinyConfig } from "../../types.js";
+import { Result } from "../../Result.js";
+import type { HttpError, GraphQLError, NetworkError } from "../../errors.js";
+export interface DeleteFileParams {
+    id: string;
+}
+/**
+ * Deletes a file from the file manager.
+ *
+ * @param config - SDK configuration
+ * @param fetchFn - Fetch function to use for HTTP requests
+ * @param params - Parameters for deleting the file
+ * @param params.id - ID of the file to delete
+ * @returns Result containing true on success or an error
+ */
+export declare function deleteFile(config: WebinyConfig, fetchFn: typeof fetch, params: DeleteFileParams): Promise<Result<boolean, HttpError | GraphQLError | NetworkError>>;

package/methods/fileManager/deleteFile.js

@@ -0,0 +1,47 @@
+import { Result } from "../../Result.js";
+/**
+ * Deletes a file from the file manager.
+ *
+ * @param config - SDK configuration
+ * @param fetchFn - Fetch function to use for HTTP requests
+ * @param params - Parameters for deleting the file
+ * @param params.id - ID of the file to delete
+ * @returns Result containing true on success or an error
+ */
+export async function deleteFile(config, fetchFn, params) {
+  const {
+    id
+  } = params;
+  const {
+    executeGraphQL
+  } = await import("../executeGraphQL.js");
+  const query = `
+        mutation DeleteFile($id: ID!) {
+            fileManager {
+                deleteFile(id: $id) {
+                    data
+                    error {
+                        message
+                        code
+                    }
+                }
+            }
+        }
+    `;
+  const result = await executeGraphQL(config, fetchFn, query, {
+    id
+  });
+  if (result.isFail()) {
+    return Result.fail(result.error);
+  }
+  const responseData = result.value;
+  if (responseData.fileManager.deleteFile.error) {
+    const {
+      GraphQLError
+    } = await import("../../errors.js");
+    return Result.fail(new GraphQLError(responseData.fileManager.deleteFile.error.message, responseData.fileManager.deleteFile.error.code));
+  }
+  return Result.ok(responseData.fileManager.deleteFile.data);
+}
+
+//# sourceMappingURL=deleteFile.js.map

package/methods/fileManager/deleteFile.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["Result","deleteFile","config","fetchFn","params","id","executeGraphQL","query","result","isFail","fail","error","responseData","value","fileManager","GraphQLError","message","code","ok","data"],"sources":["deleteFile.ts"],"sourcesContent":["import type { WebinyConfig } from \"../../types.js\";\nimport { Result } from \"../../Result.js\";\nimport type { HttpError, GraphQLError, NetworkError } from \"../../errors.js\";\n\nexport interface DeleteFileParams {\n    id: string;\n}\n\n/**\n * Deletes a file from the file manager.\n *\n * @param config - SDK configuration\n * @param fetchFn - Fetch function to use for HTTP requests\n * @param params - Parameters for deleting the file\n * @param params.id - ID of the file to delete\n * @returns Result containing true on success or an error\n */\nexport async function deleteFile(\n    config: WebinyConfig,\n    fetchFn: typeof fetch,\n    params: DeleteFileParams\n): Promise<Result<boolean, HttpError | GraphQLError | NetworkError>> {\n    const { id } = params;\n\n    const { executeGraphQL } = await import(\"../executeGraphQL.js\");\n\n    const query = `\n        mutation DeleteFile($id: ID!) {\n            fileManager {\n                deleteFile(id: $id) {\n                    data\n                    error {\n                        message\n                        code\n                    }\n                }\n            }\n        }\n    `;\n\n    const result = await executeGraphQL(config, fetchFn, query, { id });\n\n    if (result.isFail()) {\n        return Result.fail(result.error);\n    }\n\n    const responseData = result.value;\n\n    if (responseData.fileManager.deleteFile.error) {\n        const { GraphQLError } = await import(\"../../errors.js\");\n        return Result.fail(\n            new GraphQLError(\n                responseData.fileManager.deleteFile.error.message,\n                responseData.fileManager.deleteFile.error.code\n            )\n        );\n    }\n\n    return Result.ok(responseData.fileManager.deleteFile.data);\n}\n"],"mappings":"AACA,SAASA,MAAM;AAOf;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,eAAeC,UAAUA,CAC5BC,MAAoB,EACpBC,OAAqB,EACrBC,MAAwB,EACyC;EACjE,MAAM;IAAEC;EAAG,CAAC,GAAGD,MAAM;EAErB,MAAM;IAAEE;EAAe,CAAC,GAAG,MAAM,MAAM,uBAAuB,CAAC;EAE/D,MAAMC,KAAK,GAAG;AAClB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;EAED,MAAMC,MAAM,GAAG,MAAMF,cAAc,CAACJ,MAAM,EAAEC,OAAO,EAAEI,KAAK,EAAE;IAAEF;EAAG,CAAC,CAAC;EAEnE,IAAIG,MAAM,CAACC,MAAM,CAAC,CAAC,EAAE;IACjB,OAAOT,MAAM,CAACU,IAAI,CAACF,MAAM,CAACG,KAAK,CAAC;EACpC;EAEA,MAAMC,YAAY,GAAGJ,MAAM,CAACK,KAAK;EAEjC,IAAID,YAAY,CAACE,WAAW,CAACb,UAAU,CAACU,KAAK,EAAE;IAC3C,MAAM;MAAEI;IAAa,CAAC,GAAG,MAAM,MAAM,kBAAkB,CAAC;IACxD,OAAOf,MAAM,CAACU,IAAI,CACd,IAAIK,YAAY,CACZH,YAAY,CAACE,WAAW,CAACb,UAAU,CAACU,KAAK,CAACK,OAAO,EACjDJ,YAAY,CAACE,WAAW,CAACb,UAAU,CAACU,KAAK,CAACM,IAC9C,CACJ,CAAC;EACL;EAEA,OAAOjB,MAAM,CAACkB,EAAE,CAACN,YAAY,CAACE,WAAW,CAACb,UAAU,CAACkB,IAAI,CAAC;AAC9D","ignoreList":[]}

package/methods/fileManager/fileManagerTypes.d.ts

@@ -0,0 +1,117 @@
+export interface FmIdentity {
+    id: string;
+    displayName: string;
+    type: string;
+}
+export interface FmLocation {
+    folderId: string;
+}
+export interface FmFile_Metadata {
+    image?: {
+        width?: number;
+        height?: number;
+        format?: string;
+        orientation?: number;
+    };
+    exif?: Record<string, any>;
+    iptc?: Record<string, any>;
+    [key: string]: any;
+}
+export type FmFile_AccessControl = {
+    type: "public" | "private-authenticated";
+};
+export interface FmFile {
+    id: string;
+    createdOn: Date | string;
+    modifiedOn?: Date | string;
+    savedOn: Date | string;
+    createdBy: FmIdentity;
+    modifiedBy?: FmIdentity;
+    savedBy: FmIdentity;
+    location: FmLocation;
+    src?: string;
+    name?: string;
+    key?: string;
+    type?: string;
+    size?: number;
+    metadata?: FmFile_Metadata;
+    tags?: string[];
+    accessControl?: FmFile_AccessControl;
+    [key: string]: any;
+}
+export interface FmTag {
+    tag: string;
+    count: number;
+}
+export interface FmListMeta {
+    cursor: string | null;
+    hasMoreItems: boolean;
+    totalCount: number;
+}
+export interface FmLocationInput {
+    folderId: string;
+}
+export interface FmLocationWhereInput {
+    folderId?: string;
+    folderId_in?: string[];
+    folderId_not?: string;
+    folderId_not_in?: string[];
+}
+export interface FmFileListWhereInput {
+    location?: FmLocationWhereInput;
+    name?: string;
+    name_contains?: string;
+    name_not_contains?: string;
+    type?: string;
+    type_in?: string[];
+    type_not?: string;
+    type_not_in?: string[];
+    tags?: string[];
+    tags_in?: string[];
+    tags_not?: string;
+    tags_not_in?: string[];
+    AND?: FmFileListWhereInput[];
+    OR?: FmFileListWhereInput[];
+}
+export declare enum FmFileListSorter {
+    SAVED_ON_ASC = "savedOn_ASC",
+    SAVED_ON_DESC = "savedOn_DESC",
+    CREATED_ON_ASC = "createdOn_ASC",
+    CREATED_ON_DESC = "createdOn_DESC",
+    NAME_ASC = "name_ASC",
+    NAME_DESC = "name_DESC",
+    KEY_ASC = "key_ASC",
+    KEY_DESC = "key_DESC",
+    TYPE_ASC = "type_ASC",
+    TYPE_DESC = "type_DESC",
+    SIZE_ASC = "size_ASC",
+    SIZE_DESC = "size_DESC"
+}
+export interface FmTagsListWhereInput {
+    createdBy?: string;
+    tags_startsWith?: string;
+    tags_not_startsWith?: string;
+}
+export interface UploadProgress {
+    sent: number;
+    total: number;
+    percentage: number;
+}
+export interface PresignedPostPayload {
+    url: string;
+    fields: Record<string, string>;
+}
+export interface PresignedPostPayloadResponse {
+    data: PresignedPostPayload;
+    file: {
+        id: string;
+        name: string;
+        type: string;
+        size: number;
+        key: string;
+    };
+}
+export declare enum BatchUploadStrategy {
+    FAIL_FAST = "fail-fast",
+    CONTINUE = "continue"
+}

package/methods/fileManager/fileManagerTypes.js

@@ -0,0 +1,22 @@
+export let FmFileListSorter = /*#__PURE__*/function (FmFileListSorter) {
+  FmFileListSorter["SAVED_ON_ASC"] = "savedOn_ASC";
+  FmFileListSorter["SAVED_ON_DESC"] = "savedOn_DESC";
+  FmFileListSorter["CREATED_ON_ASC"] = "createdOn_ASC";
+  FmFileListSorter["CREATED_ON_DESC"] = "createdOn_DESC";
+  FmFileListSorter["NAME_ASC"] = "name_ASC";
+  FmFileListSorter["NAME_DESC"] = "name_DESC";
+  FmFileListSorter["KEY_ASC"] = "key_ASC";
+  FmFileListSorter["KEY_DESC"] = "key_DESC";
+  FmFileListSorter["TYPE_ASC"] = "type_ASC";
+  FmFileListSorter["TYPE_DESC"] = "type_DESC";
+  FmFileListSorter["SIZE_ASC"] = "size_ASC";
+  FmFileListSorter["SIZE_DESC"] = "size_DESC";
+  return FmFileListSorter;
+}({});
+export let BatchUploadStrategy = /*#__PURE__*/function (BatchUploadStrategy) {
+  BatchUploadStrategy["FAIL_FAST"] = "fail-fast";
+  BatchUploadStrategy["CONTINUE"] = "continue";
+  return BatchUploadStrategy;
+}({});
+
+//# sourceMappingURL=fileManagerTypes.js.map