@webiny/api-file-manager 0.0.0-unstable.de38392959 → 0.0.0-unstable.df7a8bb475

package/domain/file/file.model.js

@@ -0,0 +1,56 @@
+import { ModelFactory } from "@webiny/api-headless-cms/features/modelBuilder/index.js";
+import { WcpContext } from "@webiny/api-core/features/wcp/WcpContext/index.js";
+export const FILE_MODEL_ID = process.env.WEBINY_API_LEGACY_MODELS ? "fmFile" : "wbyFmFile";
+class FilePrivateModelImpl {
+  constructor(wcp) {
+    this.wcp = wcp;
+  }
+  async execute(builder) {
+    const model = builder.private({
+      modelId: FILE_MODEL_ID,
+      name: "FmFile"
+    });
+    const privateFiles = this.wcp.canUsePrivateFiles();
+    model.fields(fields => ({
+      name: fields.text().label("Name").required("Value is required."),
+      key: fields.text().label("Key").required("Value is required."),
+      type: fields.text().label("Type").required("Value is required."),
+      size: fields.number().label("Size").required("Value is required."),
+      metadata: fields.object().label("Metadata").renderer("hidden").fields(fields => ({
+        image: fields.object().label("Image").fields(fields => ({
+          width: fields.number().label("Width"),
+          height: fields.number().label("Height"),
+          format: fields.text().label("Format"),
+          orientation: fields.number().label("Orientation")
+        })),
+        // Store complete raw EXIF as JSON
+        exif: fields.searchableJson().label("EXIF Data"),
+        // Store complete raw IPTC as JSON
+        iptc: fields.searchableJson().label("IPTC Data")
+      })),
+      tags: fields.text().label("Tags").tags(["$bulk-edit"]).list().required("Value is required.")
+    }));
+    if (privateFiles) {
+      model.fields(fields => ({
+        accessControl: fields.object().label("Access Control").tags(["$bulk-edit"]).fields(fields => ({
+          type: fields.text().label("Type").predefinedValues([{
+            label: "Public",
+            value: "public",
+            selected: true
+          }, {
+            label: "Private",
+            value: "private-authenticated",
+            selected: false
+          }])
+        }))
+      }));
+    }
+    return [model];
+  }
+}
+export const FileModel = ModelFactory.createImplementation({
+  implementation: FilePrivateModelImpl,
+  dependencies: [WcpContext]
+});
+
+//# sourceMappingURL=file.model.js.map

package/domain/file/file.model.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["ModelFactory","WcpContext","FILE_MODEL_ID","process","env","WEBINY_API_LEGACY_MODELS","FilePrivateModelImpl","constructor","wcp","execute","builder","model","private","modelId","name","privateFiles","canUsePrivateFiles","fields","text","label","required","key","type","size","number","metadata","object","renderer","image","width","height","format","orientation","exif","searchableJson","iptc","tags","list","accessControl","predefinedValues","value","selected","FileModel","createImplementation","implementation","dependencies"],"sources":["file.model.ts"],"sourcesContent":["import { ModelFactory } from \"@webiny/api-headless-cms/features/modelBuilder/index.js\";\nimport { WcpContext } from \"@webiny/api-core/features/wcp/WcpContext/index.js\";\n\nexport const FILE_MODEL_ID = process.env.WEBINY_API_LEGACY_MODELS ? \"fmFile\" : \"wbyFmFile\";\n\nclass FilePrivateModelImpl implements ModelFactory.Interface {\n    public constructor(private wcp: WcpContext.Interface) {}\n\n    public async execute(builder: ModelFactory.Builder) {\n        const model = builder.private({\n            modelId: FILE_MODEL_ID,\n            name: \"FmFile\"\n        });\n        const privateFiles = this.wcp.canUsePrivateFiles();\n\n        model.fields(fields => ({\n            name: fields.text().label(\"Name\").required(\"Value is required.\"),\n            key: fields.text().label(\"Key\").required(\"Value is required.\"),\n            type: fields.text().label(\"Type\").required(\"Value is required.\"),\n            size: fields.number().label(\"Size\").required(\"Value is required.\"),\n            metadata: fields\n                .object()\n                .label(\"Metadata\")\n                .renderer(\"hidden\")\n                .fields(fields => ({\n                    image: fields\n                        .object()\n                        .label(\"Image\")\n                        .fields(fields => ({\n                            width: fields.number().label(\"Width\"),\n                            height: fields.number().label(\"Height\"),\n                            format: fields.text().label(\"Format\"),\n                            orientation: fields.number().label(\"Orientation\")\n                        })),\n                    // Store complete raw EXIF as JSON\n                    exif: fields.searchableJson().label(\"EXIF Data\"),\n                    // Store complete raw IPTC as JSON\n                    iptc: fields.searchableJson().label(\"IPTC Data\")\n                })),\n            tags: fields\n                .text()\n                .label(\"Tags\")\n                .tags([\"$bulk-edit\"])\n                .list()\n                .required(\"Value is required.\")\n        }));\n\n        if (privateFiles) {\n            model.fields(fields => ({\n                accessControl: fields\n                    .object()\n                    .label(\"Access Control\")\n                    .tags([\"$bulk-edit\"])\n                    .fields(fields => ({\n                        type: fields\n                            .text()\n                            .label(\"Type\")\n                            .predefinedValues([\n                                {\n                                    label: \"Public\",\n                                    value: \"public\",\n                                    selected: true\n                                },\n                                {\n                                    label: \"Private\",\n                                    value: \"private-authenticated\",\n                                    selected: false\n                                }\n                            ])\n                    }))\n            }));\n        }\n\n        return [model];\n    }\n}\n\nexport const FileModel = ModelFactory.createImplementation({\n    implementation: FilePrivateModelImpl,\n    dependencies: [WcpContext]\n});\n"],"mappings":"AAAA,SAASA,YAAY,QAAQ,yDAAyD;AACtF,SAASC,UAAU,QAAQ,mDAAmD;AAE9E,OAAO,MAAMC,aAAa,GAAGC,OAAO,CAACC,GAAG,CAACC,wBAAwB,GAAG,QAAQ,GAAG,WAAW;AAE1F,MAAMC,oBAAoB,CAAmC;EAClDC,WAAWA,CAASC,GAAyB,EAAE;IAAA,KAA3BA,GAAyB,GAAzBA,GAAyB;EAAG;EAEvD,MAAaC,OAAOA,CAACC,OAA6B,EAAE;IAChD,MAAMC,KAAK,GAAGD,OAAO,CAACE,OAAO,CAAC;MAC1BC,OAAO,EAAEX,aAAa;MACtBY,IAAI,EAAE;IACV,CAAC,CAAC;IACF,MAAMC,YAAY,GAAG,IAAI,CAACP,GAAG,CAACQ,kBAAkB,CAAC,CAAC;IAElDL,KAAK,CAACM,MAAM,CAACA,MAAM,KAAK;MACpBH,IAAI,EAAEG,MAAM,CAACC,IAAI,CAAC,CAAC,CAACC,KAAK,CAAC,MAAM,CAAC,CAACC,QAAQ,CAAC,oBAAoB,CAAC;MAChEC,GAAG,EAAEJ,MAAM,CAACC,IAAI,CAAC,CAAC,CAACC,KAAK,CAAC,KAAK,CAAC,CAACC,QAAQ,CAAC,oBAAoB,CAAC;MAC9DE,IAAI,EAAEL,MAAM,CAACC,IAAI,CAAC,CAAC,CAACC,KAAK,CAAC,MAAM,CAAC,CAACC,QAAQ,CAAC,oBAAoB,CAAC;MAChEG,IAAI,EAAEN,MAAM,CAACO,MAAM,CAAC,CAAC,CAACL,KAAK,CAAC,MAAM,CAAC,CAACC,QAAQ,CAAC,oBAAoB,CAAC;MAClEK,QAAQ,EAAER,MAAM,CACXS,MAAM,CAAC,CAAC,CACRP,KAAK,CAAC,UAAU,CAAC,CACjBQ,QAAQ,CAAC,QAAQ,CAAC,CAClBV,MAAM,CAACA,MAAM,KAAK;QACfW,KAAK,EAAEX,MAAM,CACRS,MAAM,CAAC,CAAC,CACRP,KAAK,CAAC,OAAO,CAAC,CACdF,MAAM,CAACA,MAAM,KAAK;UACfY,KAAK,EAAEZ,MAAM,CAACO,MAAM,CAAC,CAAC,CAACL,KAAK,CAAC,OAAO,CAAC;UACrCW,MAAM,EAAEb,MAAM,CAACO,MAAM,CAAC,CAAC,CAACL,KAAK,CAAC,QAAQ,CAAC;UACvCY,MAAM,EAAEd,MAAM,CAACC,IAAI,CAAC,CAAC,CAACC,KAAK,CAAC,QAAQ,CAAC;UACrCa,WAAW,EAAEf,MAAM,CAACO,MAAM,CAAC,CAAC,CAACL,KAAK,CAAC,aAAa;QACpD,CAAC,CAAC,CAAC;QACP;QACAc,IAAI,EAAEhB,MAAM,CAACiB,cAAc,CAAC,CAAC,CAACf,KAAK,CAAC,WAAW,CAAC;QAChD;QACAgB,IAAI,EAAElB,MAAM,CAACiB,cAAc,CAAC,CAAC,CAACf,KAAK,CAAC,WAAW;MACnD,CAAC,CAAC,CAAC;MACPiB,IAAI,EAAEnB,MAAM,CACPC,IAAI,CAAC,CAAC,CACNC,KAAK,CAAC,MAAM,CAAC,CACbiB,IAAI,CAAC,CAAC,YAAY,CAAC,CAAC,CACpBC,IAAI,CAAC,CAAC,CACNjB,QAAQ,CAAC,oBAAoB;IACtC,CAAC,CAAC,CAAC;IAEH,IAAIL,YAAY,EAAE;MACdJ,KAAK,CAACM,MAAM,CAACA,MAAM,KAAK;QACpBqB,aAAa,EAAErB,MAAM,CAChBS,MAAM,CAAC,CAAC,CACRP,KAAK,CAAC,gBAAgB,CAAC,CACvBiB,IAAI,CAAC,CAAC,YAAY,CAAC,CAAC,CACpBnB,MAAM,CAACA,MAAM,KAAK;UACfK,IAAI,EAAEL,MAAM,CACPC,IAAI,CAAC,CAAC,CACNC,KAAK,CAAC,MAAM,CAAC,CACboB,gBAAgB,CAAC,CACd;YACIpB,KAAK,EAAE,QAAQ;YACfqB,KAAK,EAAE,QAAQ;YACfC,QAAQ,EAAE;UACd,CAAC,EACD;YACItB,KAAK,EAAE,SAAS;YAChBqB,KAAK,EAAE,uBAAuB;YAC9BC,QAAQ,EAAE;UACd,CAAC,CACJ;QACT,CAAC,CAAC;MACV,CAAC,CAAC,CAAC;IACP;IAEA,OAAO,CAAC9B,KAAK,CAAC;EAClB;AACJ;AAEA,OAAO,MAAM+B,SAAS,GAAG1C,YAAY,CAAC2C,oBAAoB,CAAC;EACvDC,cAAc,EAAEtC,oBAAoB;EACpCuC,YAAY,EAAE,CAAC5C,UAAU;AAC7B,CAAC,CAAC","ignoreList":[]}

package/domain/file/types.d.ts

@@ -0,0 +1,51 @@
+export type PublicAccess = {
+    type: "public";
+};
+export type PrivateAuthenticatedAccess = {
+    type: "private-authenticated";
+};
+export type FileAccess = PublicAccess | PrivateAuthenticatedAccess;
+export interface CreatedBy {
+    id: string;
+    displayName: string;
+    type: string;
+}
+export interface File {
+    id: string;
+    key: string;
+    size: number;
+    type: string;
+    name: string;
+    metadata: Record<string, any>;
+    accessControl?: FileAccess;
+    location: {
+        folderId: string;
+    };
+    tags: string[];
+    createdOn: string;
+    modifiedOn: string | undefined;
+    savedOn: string;
+    createdBy: CreatedBy;
+    modifiedBy: CreatedBy | undefined;
+    savedBy: CreatedBy;
+    extensions?: Record<string, any>;
+}
+export interface FileInput {
+    id: string;
+    createdOn?: string;
+    modifiedOn?: string;
+    savedOn?: string;
+    createdBy?: CreatedBy;
+    modifiedBy?: CreatedBy;
+    savedBy?: CreatedBy;
+    key: string;
+    name: string;
+    size: number;
+    type: string;
+    metadata: Record<string, any>;
+    location?: {
+        folderId: string;
+    };
+    tags: string[];
+    extensions?: Record<string, any>;
+}

package/domain/file/types.js

@@ -0,0 +1,3 @@
+export {};
+
+//# sourceMappingURL=types.js.map

package/domain/file/types.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sources":["types.ts"],"sourcesContent":["export type PublicAccess = {\n    type: \"public\";\n};\n\nexport type PrivateAuthenticatedAccess = {\n    type: \"private-authenticated\";\n};\n\nexport type FileAccess = PublicAccess | PrivateAuthenticatedAccess;\n\nexport interface CreatedBy {\n    id: string;\n    displayName: string;\n    type: string;\n}\n\nexport interface File {\n    id: string;\n    key: string;\n    size: number;\n    type: string;\n    name: string;\n    metadata: Record<string, any>;\n    accessControl?: FileAccess;\n    location: {\n        folderId: string;\n    };\n    tags: string[];\n    createdOn: string;\n    modifiedOn: string | undefined;\n    savedOn: string;\n    createdBy: CreatedBy;\n    modifiedBy: CreatedBy | undefined;\n    savedBy: CreatedBy;\n    extensions?: Record<string, any>;\n}\n\nexport interface FileInput {\n    id: string;\n\n    // Entry-level fields (we don't use revisions for files)\n    createdOn?: string;\n    modifiedOn?: string;\n    savedOn?: string;\n    createdBy?: CreatedBy;\n    modifiedBy?: CreatedBy;\n    savedBy?: CreatedBy;\n\n    key: string;\n    name: string;\n    size: number;\n    type: string;\n    metadata: Record<string, any>;\n    location?: {\n        folderId: string;\n    };\n    tags: string[];\n    extensions?: Record<string, any>;\n}\n"],"mappings":"","ignoreList":[]}

package/domain/identity/Identity.d.ts

@@ -0,0 +1,9 @@
+interface IdentityDto {
+    id: string;
+    displayName: string;
+    type: string;
+}
+export declare class Identity {
+    static from(identity: IdentityDto): IdentityDto;
+}
+export {};

package/domain/identity/Identity.js

@@ -0,0 +1,11 @@
+export class Identity {
+  static from(identity) {
+    return {
+      id: identity.id,
+      displayName: identity.displayName,
+      type: identity.type
+    };
+  }
+}
+
+//# sourceMappingURL=Identity.js.map

package/domain/identity/Identity.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["Identity","from","identity","id","displayName","type"],"sources":["Identity.ts"],"sourcesContent":["interface IdentityDto {\n    id: string;\n    displayName: string;\n    type: string;\n}\n\nexport class Identity {\n    static from(identity: IdentityDto): IdentityDto {\n        return {\n            id: identity.id,\n            displayName: identity.displayName,\n            type: identity.type\n        };\n    }\n}\n"],"mappings":"AAMA,OAAO,MAAMA,QAAQ,CAAC;EAClB,OAAOC,IAAIA,CAACC,QAAqB,EAAe;IAC5C,OAAO;MACHC,EAAE,EAAED,QAAQ,CAACC,EAAE;MACfC,WAAW,EAAEF,QAAQ,CAACE,WAAW;MACjCC,IAAI,EAAEH,QAAQ,CAACG;IACnB,CAAC;EACL;AACJ","ignoreList":[]}

package/domain/settings/constants.d.ts

@@ -0,0 +1 @@
+export declare const FILE_MANAGER_GENERAL_SETTINGS = "FileManager/General";

package/domain/settings/constants.js

@@ -0,0 +1,3 @@
+export const FILE_MANAGER_GENERAL_SETTINGS = "FileManager/General";
+
+//# sourceMappingURL=constants.js.map

package/domain/settings/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["FILE_MANAGER_GENERAL_SETTINGS"],"sources":["constants.ts"],"sourcesContent":["export const FILE_MANAGER_GENERAL_SETTINGS = \"FileManager/General\";\n"],"mappings":"AAAA,OAAO,MAAMA,6BAA6B,GAAG,qBAAqB","ignoreList":[]}

package/domain/settings/errors.d.ts

@@ -0,0 +1,18 @@
+import { BaseError } from "@webiny/feature/api";
+import type { OutputErrors } from "@webiny/utils/createZodError.js";
+export declare class SettingsNotFoundError extends BaseError {
+    readonly code: "FileManager/Settings/NotFoundError";
+    constructor();
+}
+export declare class SettingsUpdateError extends BaseError {
+    readonly code: "FileManager/Settings/UpdateError";
+    constructor(error: Error);
+}
+interface ValidationParams {
+    invalidFields: OutputErrors;
+}
+export declare class SettingsValidationError extends BaseError<ValidationParams> {
+    readonly code: "FileManager/Settings/ValidationError";
+    constructor(invalidFields: OutputErrors);
+}
+export {};

package/domain/settings/errors.js

@@ -0,0 +1,30 @@
+import { BaseError } from "@webiny/feature/api";
+export class SettingsNotFoundError extends BaseError {
+  code = "FileManager/Settings/NotFoundError";
+  constructor() {
+    super({
+      message: "File manager settings not found."
+    });
+  }
+}
+export class SettingsUpdateError extends BaseError {
+  code = "FileManager/Settings/UpdateError";
+  constructor(error) {
+    super({
+      message: `Error updating settings: ${error.message}`
+    });
+  }
+}
+export class SettingsValidationError extends BaseError {
+  code = "FileManager/Settings/ValidationError";
+  constructor(invalidFields) {
+    super({
+      message: "Validation failed.",
+      data: {
+        invalidFields
+      }
+    });
+  }
+}
+
+//# sourceMappingURL=errors.js.map

package/domain/settings/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["BaseError","SettingsNotFoundError","code","constructor","message","SettingsUpdateError","error","SettingsValidationError","invalidFields","data"],"sources":["errors.ts"],"sourcesContent":["import { BaseError } from \"@webiny/feature/api\";\nimport type { OutputErrors } from \"@webiny/utils/createZodError.js\";\n\nexport class SettingsNotFoundError extends BaseError {\n    override readonly code = \"FileManager/Settings/NotFoundError\" as const;\n\n    constructor() {\n        super({\n            message: \"File manager settings not found.\"\n        });\n    }\n}\n\nexport class SettingsUpdateError extends BaseError {\n    override readonly code = \"FileManager/Settings/UpdateError\" as const;\n\n    constructor(error: Error) {\n        super({\n            message: `Error updating settings: ${error.message}`\n        });\n    }\n}\n\ninterface ValidationParams {\n    invalidFields: OutputErrors;\n}\n\nexport class SettingsValidationError extends BaseError<ValidationParams> {\n    override readonly code = \"FileManager/Settings/ValidationError\" as const;\n\n    constructor(invalidFields: OutputErrors) {\n        super({\n            message: \"Validation failed.\",\n            data: { invalidFields }\n        });\n    }\n}\n"],"mappings":"AAAA,SAASA,SAAS,QAAQ,qBAAqB;AAG/C,OAAO,MAAMC,qBAAqB,SAASD,SAAS,CAAC;EAC/BE,IAAI,GAAG,oCAAoC;EAE7DC,WAAWA,CAAA,EAAG;IACV,KAAK,CAAC;MACFC,OAAO,EAAE;IACb,CAAC,CAAC;EACN;AACJ;AAEA,OAAO,MAAMC,mBAAmB,SAASL,SAAS,CAAC;EAC7BE,IAAI,GAAG,kCAAkC;EAE3DC,WAAWA,CAACG,KAAY,EAAE;IACtB,KAAK,CAAC;MACFF,OAAO,EAAE,4BAA4BE,KAAK,CAACF,OAAO;IACtD,CAAC,CAAC;EACN;AACJ;AAMA,OAAO,MAAMG,uBAAuB,SAASP,SAAS,CAAmB;EACnDE,IAAI,GAAG,sCAAsC;EAE/DC,WAAWA,CAACK,aAA2B,EAAE;IACrC,KAAK,CAAC;MACFJ,OAAO,EAAE,oBAAoB;MAC7BK,IAAI,EAAE;QAAED;MAAc;IAC1B,CAAC,CAAC;EACN;AACJ","ignoreList":[]}

package/domain/settings/types.d.ts

@@ -0,0 +1,10 @@
+export interface FileManagerSettings {
+    uploadMinFileSize: number;
+    uploadMaxFileSize: number;
+    srcPrefix: string;
+}
+export interface UpdateSettingsInput {
+    uploadMinFileSize?: number;
+    uploadMaxFileSize?: number;
+    srcPrefix?: string;
+}

package/domain/settings/types.js

@@ -0,0 +1,3 @@
+export {};
+
+//# sourceMappingURL=types.js.map

package/domain/settings/types.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sources":["types.ts"],"sourcesContent":["export interface FileManagerSettings {\n    uploadMinFileSize: number;\n    uploadMaxFileSize: number;\n    srcPrefix: string;\n}\n\nexport interface UpdateSettingsInput {\n    uploadMinFileSize?: number;\n    uploadMaxFileSize?: number;\n    srcPrefix?: string;\n}\n"],"mappings":"","ignoreList":[]}

package/domain/settings/validation.d.ts

@@ -0,0 +1,14 @@
+import zod from "zod";
+export declare const updateSettingsValidation: zod.ZodObject<{
+    uploadMinFileSize: zod.ZodOptional<zod.ZodEffects<zod.ZodOptional<zod.ZodNullable<zod.ZodNumber>>, number, number | null | undefined>>;
+    uploadMaxFileSize: zod.ZodOptional<zod.ZodEffects<zod.ZodOptional<zod.ZodNullable<zod.ZodNumber>>, number, number | null | undefined>>;
+    srcPrefix: zod.ZodEffects<zod.ZodOptional<zod.ZodString>, string, string | undefined>;
+}, "strip", zod.ZodTypeAny, {
+    srcPrefix: string;
+    uploadMinFileSize?: number | undefined;
+    uploadMaxFileSize?: number | undefined;
+}, {
+    uploadMinFileSize?: number | null | undefined;
+    uploadMaxFileSize?: number | null | undefined;
+    srcPrefix?: string | undefined;
+}>;

package/domain/settings/validation.js

@@ -0,0 +1,36 @@
+import zod from "zod";
+import { ServiceDiscovery } from "@webiny/api";
+const MIN_FILE_SIZE = 0;
+const MAX_FILE_SIZE = 10737418240;
+const uploadMinFileSizeValidation = zod.number().min(MIN_FILE_SIZE, {
+  message: `Value needs to be greater than or equal to ${MIN_FILE_SIZE}.`
+}).nullish().transform(value => {
+  return value || MIN_FILE_SIZE;
+}).optional();
+const uploadMaxFileSizeValidation = zod.number().max(MAX_FILE_SIZE, {
+  message: `Value needs to be lesser than or equal to ${MAX_FILE_SIZE}.`
+}).nullish().transform(value => {
+  return value || MAX_FILE_SIZE;
+}).optional();
+export const updateSettingsValidation = zod.object({
+  uploadMinFileSize: uploadMinFileSizeValidation,
+  uploadMaxFileSize: uploadMaxFileSizeValidation,
+  srcPrefix: zod.string().optional().transform(async value => {
+    if (!value) {
+      const manifest = await ServiceDiscovery.load();
+      if (!manifest || !manifest.api) {
+        return "";
+      }
+      const {
+        domain
+      } = manifest.api.cloudfront;
+      return `https://${domain}/files/`;
+    }
+    if (typeof value === "string") {
+      return value.endsWith("/") ? value : value + "/";
+    }
+    return value;
+  })
+});
+
+//# sourceMappingURL=validation.js.map

package/domain/settings/validation.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["zod","ServiceDiscovery","MIN_FILE_SIZE","MAX_FILE_SIZE","uploadMinFileSizeValidation","number","min","message","nullish","transform","value","optional","uploadMaxFileSizeValidation","max","updateSettingsValidation","object","uploadMinFileSize","uploadMaxFileSize","srcPrefix","string","manifest","load","api","domain","cloudfront","endsWith"],"sources":["validation.ts"],"sourcesContent":["import zod from \"zod\";\nimport { ServiceDiscovery } from \"@webiny/api\";\n\nconst MIN_FILE_SIZE = 0;\nconst MAX_FILE_SIZE = 10737418240;\n\nconst uploadMinFileSizeValidation = zod\n    .number()\n    .min(MIN_FILE_SIZE, {\n        message: `Value needs to be greater than or equal to ${MIN_FILE_SIZE}.`\n    })\n    .nullish()\n    .transform(value => {\n        return value || MIN_FILE_SIZE;\n    })\n    .optional();\n\nconst uploadMaxFileSizeValidation = zod\n    .number()\n    .max(MAX_FILE_SIZE, {\n        message: `Value needs to be lesser than or equal to ${MAX_FILE_SIZE}.`\n    })\n    .nullish()\n    .transform(value => {\n        return value || MAX_FILE_SIZE;\n    })\n    .optional();\n\nexport const updateSettingsValidation = zod.object({\n    uploadMinFileSize: uploadMinFileSizeValidation,\n    uploadMaxFileSize: uploadMaxFileSizeValidation,\n    srcPrefix: zod\n        .string()\n        .optional()\n        .transform(async value => {\n            if (!value) {\n                const manifest = await ServiceDiscovery.load();\n                if (!manifest || !manifest.api) {\n                    return \"\";\n                }\n\n                const { domain } = manifest.api.cloudfront;\n\n                return `https://${domain}/files/`;\n            }\n            if (typeof value === \"string\") {\n                return value.endsWith(\"/\") ? value : value + \"/\";\n            }\n            return value;\n        })\n});\n"],"mappings":"AAAA,OAAOA,GAAG,MAAM,KAAK;AACrB,SAASC,gBAAgB,QAAQ,aAAa;AAE9C,MAAMC,aAAa,GAAG,CAAC;AACvB,MAAMC,aAAa,GAAG,WAAW;AAEjC,MAAMC,2BAA2B,GAAGJ,GAAG,CAClCK,MAAM,CAAC,CAAC,CACRC,GAAG,CAACJ,aAAa,EAAE;EAChBK,OAAO,EAAE,8CAA8CL,aAAa;AACxE,CAAC,CAAC,CACDM,OAAO,CAAC,CAAC,CACTC,SAAS,CAACC,KAAK,IAAI;EAChB,OAAOA,KAAK,IAAIR,aAAa;AACjC,CAAC,CAAC,CACDS,QAAQ,CAAC,CAAC;AAEf,MAAMC,2BAA2B,GAAGZ,GAAG,CAClCK,MAAM,CAAC,CAAC,CACRQ,GAAG,CAACV,aAAa,EAAE;EAChBI,OAAO,EAAE,6CAA6CJ,aAAa;AACvE,CAAC,CAAC,CACDK,OAAO,CAAC,CAAC,CACTC,SAAS,CAACC,KAAK,IAAI;EAChB,OAAOA,KAAK,IAAIP,aAAa;AACjC,CAAC,CAAC,CACDQ,QAAQ,CAAC,CAAC;AAEf,OAAO,MAAMG,wBAAwB,GAAGd,GAAG,CAACe,MAAM,CAAC;EAC/CC,iBAAiB,EAAEZ,2BAA2B;EAC9Ca,iBAAiB,EAAEL,2BAA2B;EAC9CM,SAAS,EAAElB,GAAG,CACTmB,MAAM,CAAC,CAAC,CACRR,QAAQ,CAAC,CAAC,CACVF,SAAS,CAAC,MAAMC,KAAK,IAAI;IACtB,IAAI,CAACA,KAAK,EAAE;MACR,MAAMU,QAAQ,GAAG,MAAMnB,gBAAgB,CAACoB,IAAI,CAAC,CAAC;MAC9C,IAAI,CAACD,QAAQ,IAAI,CAACA,QAAQ,CAACE,GAAG,EAAE;QAC5B,OAAO,EAAE;MACb;MAEA,MAAM;QAAEC;MAAO,CAAC,GAAGH,QAAQ,CAACE,GAAG,CAACE,UAAU;MAE1C,OAAO,WAAWD,MAAM,SAAS;IACrC;IACA,IAAI,OAAOb,KAAK,KAAK,QAAQ,EAAE;MAC3B,OAAOA,KAAK,CAACe,QAAQ,CAAC,GAAG,CAAC,GAAGf,KAAK,GAAGA,KAAK,GAAG,GAAG;IACpD;IACA,OAAOA,KAAK;EAChB,CAAC;AACT,CAAC,CAAC","ignoreList":[]}

package/features/FileManagerFeature.d.ts

@@ -0,0 +1 @@
+export declare const FileManagerFeature: import("@webiny/feature/api/createFeature").FeatureDefinition<unknown>;

package/features/FileManagerFeature.js

@@ -0,0 +1,28 @@
+import { createFeature } from "@webiny/feature/api";
+import { CreateFileFeature } from "./file/CreateFile/feature.js";
+import { CreateFilesInBatchFeature } from "./file/CreateFilesInBatch/feature.js";
+import { DeleteFileFeature } from "./file/DeleteFile/feature.js";
+import { GetFileFeature } from "./file/GetFile/feature.js";
+import { ListFilesFeature } from "./file/ListFiles/feature.js";
+import { ListTagsFeature } from "./file/ListTags/feature.js";
+import { UpdateFileFeature } from "./file/UpdateFile/feature.js";
+import { SettingsInstallerFeature } from "./settings/SettingsInstaller/feature.js";
+import { GetSettingsFeature } from "./settings/GetSettings/feature.js";
+import { UpdateSettingsFeature } from "./settings/UpdateSettings/feature.js";
+export const FileManagerFeature = createFeature({
+  name: "FileManager",
+  register(container) {
+    CreateFileFeature.register(container);
+    CreateFilesInBatchFeature.register(container);
+    UpdateFileFeature.register(container);
+    DeleteFileFeature.register(container);
+    GetFileFeature.register(container);
+    ListFilesFeature.register(container);
+    ListTagsFeature.register(container);
+    SettingsInstallerFeature.register(container);
+    GetSettingsFeature.register(container);
+    UpdateSettingsFeature.register(container);
+  }
+});
+
+//# sourceMappingURL=FileManagerFeature.js.map

package/features/FileManagerFeature.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["createFeature","CreateFileFeature","CreateFilesInBatchFeature","DeleteFileFeature","GetFileFeature","ListFilesFeature","ListTagsFeature","UpdateFileFeature","SettingsInstallerFeature","GetSettingsFeature","UpdateSettingsFeature","FileManagerFeature","name","register","container"],"sources":["FileManagerFeature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { CreateFileFeature } from \"~/features/file/CreateFile/feature.js\";\nimport { CreateFilesInBatchFeature } from \"~/features/file/CreateFilesInBatch/feature.js\";\nimport { DeleteFileFeature } from \"~/features/file/DeleteFile/feature.js\";\nimport { GetFileFeature } from \"~/features/file/GetFile/feature.js\";\nimport { ListFilesFeature } from \"~/features/file/ListFiles/feature.js\";\nimport { ListTagsFeature } from \"~/features/file/ListTags/feature.js\";\nimport { UpdateFileFeature } from \"~/features/file/UpdateFile/feature.js\";\nimport { SettingsInstallerFeature } from \"~/features/settings/SettingsInstaller/feature.js\";\nimport { GetSettingsFeature } from \"~/features/settings/GetSettings/feature.js\";\nimport { UpdateSettingsFeature } from \"~/features/settings/UpdateSettings/feature.js\";\n\nexport const FileManagerFeature = createFeature({\n    name: \"FileManager\",\n    register(container) {\n        CreateFileFeature.register(container);\n        CreateFilesInBatchFeature.register(container);\n        UpdateFileFeature.register(container);\n        DeleteFileFeature.register(container);\n        GetFileFeature.register(container);\n        ListFilesFeature.register(container);\n        ListTagsFeature.register(container);\n        SettingsInstallerFeature.register(container);\n        GetSettingsFeature.register(container);\n        UpdateSettingsFeature.register(container);\n    }\n});\n"],"mappings":"AAAA,SAASA,aAAa,QAAQ,qBAAqB;AACnD,SAASC,iBAAiB;AAC1B,SAASC,yBAAyB;AAClC,SAASC,iBAAiB;AAC1B,SAASC,cAAc;AACvB,SAASC,gBAAgB;AACzB,SAASC,eAAe;AACxB,SAASC,iBAAiB;AAC1B,SAASC,wBAAwB;AACjC,SAASC,kBAAkB;AAC3B,SAASC,qBAAqB;AAE9B,OAAO,MAAMC,kBAAkB,GAAGX,aAAa,CAAC;EAC5CY,IAAI,EAAE,aAAa;EACnBC,QAAQA,CAACC,SAAS,EAAE;IAChBb,iBAAiB,CAACY,QAAQ,CAACC,SAAS,CAAC;IACrCZ,yBAAyB,CAACW,QAAQ,CAACC,SAAS,CAAC;IAC7CP,iBAAiB,CAACM,QAAQ,CAACC,SAAS,CAAC;IACrCX,iBAAiB,CAACU,QAAQ,CAACC,SAAS,CAAC;IACrCV,cAAc,CAACS,QAAQ,CAACC,SAAS,CAAC;IAClCT,gBAAgB,CAACQ,QAAQ,CAACC,SAAS,CAAC;IACpCR,eAAe,CAACO,QAAQ,CAACC,SAAS,CAAC;IACnCN,wBAAwB,CAACK,QAAQ,CAACC,SAAS,CAAC;IAC5CL,kBAAkB,CAACI,QAAQ,CAACC,SAAS,CAAC;IACtCJ,qBAAqB,CAACG,QAAQ,CAACC,SAAS,CAAC;EAC7C;AACJ,CAAC,CAAC","ignoreList":[]}

package/features/file/CreateFile/CreateFileRepository.d.ts

@@ -0,0 +1,15 @@
+import { Result } from "@webiny/feature/api";
+import { CreateFileRepository as RepositoryAbstraction } from "./abstractions.js";
+import { CreateEntryUseCase } from "@webiny/api-headless-cms/features/contentEntry/CreateEntry";
+import { FileModel } from "../../../domain/file/abstractions.js";
+import type { File, FileInput } from "../../../domain/file/types.js";
+declare class CreateFileRepositoryImpl implements RepositoryAbstraction.Interface {
+    private createEntry;
+    private fileModel;
+    constructor(createEntry: CreateEntryUseCase.Interface, fileModel: FileModel.Interface);
+    execute(data: FileInput): Promise<Result<File, RepositoryAbstraction.Error>>;
+}
+export declare const CreateFileRepository: typeof CreateFileRepositoryImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").ICreateFileRepository>;
+};
+export {};

package/features/file/CreateFile/CreateFileRepository.js

@@ -0,0 +1,30 @@
+import { Result } from "@webiny/feature/api";
+import { CreateFileRepository as RepositoryAbstraction } from "./abstractions.js";
+import { CreateEntryUseCase } from "@webiny/api-headless-cms/features/contentEntry/CreateEntry";
+import { FileModel } from "../../../domain/file/abstractions.js";
+import { EntryToFileMapper } from "../shared/EntryToFileMapper.js";
+import { FileNotAuthorizedError, FilePersistenceError } from "../../../domain/file/errors.js";
+import { FileInputToEntryInputMapper } from "../shared/FileInputToEntryInputMapper.js";
+class CreateFileRepositoryImpl {
+  constructor(createEntry, fileModel) {
+    this.createEntry = createEntry;
+    this.fileModel = fileModel;
+  }
+  async execute(data) {
+    const result = await this.createEntry.execute(this.fileModel, FileInputToEntryInputMapper.toEntry(data));
+    if (result.isFail()) {
+      if (result.error.code === "Cms/Entry/NotAuthorized") {
+        return Result.fail(new FileNotAuthorizedError());
+      }
+      return Result.fail(new FilePersistenceError(result.error));
+    }
+    const file = EntryToFileMapper.toFile(result.value);
+    return Result.ok(file);
+  }
+}
+export const CreateFileRepository = RepositoryAbstraction.createImplementation({
+  implementation: CreateFileRepositoryImpl,
+  dependencies: [CreateEntryUseCase, FileModel]
+});
+
+//# sourceMappingURL=CreateFileRepository.js.map

package/features/file/CreateFile/CreateFileRepository.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["Result","CreateFileRepository","RepositoryAbstraction","CreateEntryUseCase","FileModel","EntryToFileMapper","FileNotAuthorizedError","FilePersistenceError","FileInputToEntryInputMapper","CreateFileRepositoryImpl","constructor","createEntry","fileModel","execute","data","result","toEntry","isFail","error","code","fail","file","toFile","value","ok","createImplementation","implementation","dependencies"],"sources":["CreateFileRepository.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { CreateFileRepository as RepositoryAbstraction } from \"./abstractions.js\";\nimport { CreateEntryUseCase } from \"@webiny/api-headless-cms/features/contentEntry/CreateEntry\";\nimport { FileModel } from \"~/domain/file/abstractions.js\";\nimport type { File, FileInput } from \"~/domain/file/types.js\";\nimport { EntryToFileMapper } from \"../shared/EntryToFileMapper.js\";\nimport { FileNotAuthorizedError, FilePersistenceError } from \"~/domain/file/errors.js\";\nimport { FileInputToEntryInputMapper } from \"~/features/file/shared/FileInputToEntryInputMapper.js\";\n\nclass CreateFileRepositoryImpl implements RepositoryAbstraction.Interface {\n    constructor(\n        private createEntry: CreateEntryUseCase.Interface,\n        private fileModel: FileModel.Interface\n    ) {}\n\n    async execute(data: FileInput): Promise<Result<File, RepositoryAbstraction.Error>> {\n        const result = await this.createEntry.execute(\n            this.fileModel,\n            FileInputToEntryInputMapper.toEntry(data)\n        );\n\n        if (result.isFail()) {\n            if (result.error.code === \"Cms/Entry/NotAuthorized\") {\n                return Result.fail(new FileNotAuthorizedError());\n            }\n\n            return Result.fail(new FilePersistenceError(result.error));\n        }\n\n        const file = EntryToFileMapper.toFile(result.value);\n        return Result.ok(file);\n    }\n}\n\nexport const CreateFileRepository = RepositoryAbstraction.createImplementation({\n    implementation: CreateFileRepositoryImpl,\n    dependencies: [CreateEntryUseCase, FileModel]\n});\n"],"mappings":"AAAA,SAASA,MAAM,QAAQ,qBAAqB;AAC5C,SAASC,oBAAoB,IAAIC,qBAAqB;AACtD,SAASC,kBAAkB,QAAQ,4DAA4D;AAC/F,SAASC,SAAS;AAElB,SAASC,iBAAiB;AAC1B,SAASC,sBAAsB,EAAEC,oBAAoB;AACrD,SAASC,2BAA2B;AAEpC,MAAMC,wBAAwB,CAA4C;EACtEC,WAAWA,CACCC,WAAyC,EACzCC,SAA8B,EACxC;IAAA,KAFUD,WAAyC,GAAzCA,WAAyC;IAAA,KACzCC,SAA8B,GAA9BA,SAA8B;EACvC;EAEH,MAAMC,OAAOA,CAACC,IAAe,EAAsD;IAC/E,MAAMC,MAAM,GAAG,MAAM,IAAI,CAACJ,WAAW,CAACE,OAAO,CACzC,IAAI,CAACD,SAAS,EACdJ,2BAA2B,CAACQ,OAAO,CAACF,IAAI,CAC5C,CAAC;IAED,IAAIC,MAAM,CAACE,MAAM,CAAC,CAAC,EAAE;MACjB,IAAIF,MAAM,CAACG,KAAK,CAACC,IAAI,KAAK,yBAAyB,EAAE;QACjD,OAAOnB,MAAM,CAACoB,IAAI,CAAC,IAAId,sBAAsB,CAAC,CAAC,CAAC;MACpD;MAEA,OAAON,MAAM,CAACoB,IAAI,CAAC,IAAIb,oBAAoB,CAACQ,MAAM,CAACG,KAAK,CAAC,CAAC;IAC9D;IAEA,MAAMG,IAAI,GAAGhB,iBAAiB,CAACiB,MAAM,CAACP,MAAM,CAACQ,KAAK,CAAC;IACnD,OAAOvB,MAAM,CAACwB,EAAE,CAACH,IAAI,CAAC;EAC1B;AACJ;AAEA,OAAO,MAAMpB,oBAAoB,GAAGC,qBAAqB,CAACuB,oBAAoB,CAAC;EAC3EC,cAAc,EAAEjB,wBAAwB;EACxCkB,YAAY,EAAE,CAACxB,kBAAkB,EAAEC,SAAS;AAChD,CAAC,CAAC","ignoreList":[]}

package/features/file/CreateFile/CreateFileUseCase.d.ts

@@ -0,0 +1,21 @@
+import { Result } from "@webiny/feature/api";
+import { CreateFileUseCase as UseCaseAbstraction, CreateFileInput, CreateFileRepository } from "./abstractions.js";
+import { GetSettingsUseCase } from "../../settings/GetSettings/abstractions.js";
+import { EventPublisher } from "@webiny/api-core/features/EventPublisher";
+import type { File } from "../../../domain/file/types.js";
+import { FilePermissions } from "../../../features/shared/abstractions.js";
+import { IdentityContext } from "@webiny/api-core/features/security/IdentityContext/index.js";
+declare class CreateFileUseCaseImpl implements UseCaseAbstraction.Interface {
+    private identityContext;
+    private filePermissions;
+    private repository;
+    private getSettings;
+    private eventPublisher;
+    constructor(identityContext: IdentityContext.Interface, filePermissions: FilePermissions.Interface, repository: CreateFileRepository.Interface, getSettings: GetSettingsUseCase.Interface, eventPublisher: EventPublisher.Interface);
+    execute(input: CreateFileInput, meta?: Record<string, any>): Promise<Result<File, UseCaseAbstraction.Error>>;
+    private validateInput;
+}
+export declare const CreateFileUseCase: typeof CreateFileUseCaseImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").ICreateFileUseCase>;
+};
+export {};

package/features/file/CreateFile/CreateFileUseCase.js

@@ -0,0 +1,91 @@
+import { Result } from "@webiny/feature/api";
+import { CreateFileUseCase as UseCaseAbstraction, CreateFileRepository } from "./abstractions.js";
+import { GetSettingsUseCase } from "../../settings/GetSettings/abstractions.js";
+import { EventPublisher } from "@webiny/api-core/features/EventPublisher";
+import { FileNotAuthorizedError, InvalidFileSizeError } from "../../../domain/file/errors.js";
+import { FileBeforeCreateEvent, FileAfterCreateEvent } from "./events.js";
+import { FilePermissions } from "../../shared/abstractions.js";
+import { IdentityContext } from "@webiny/api-core/features/security/IdentityContext/index.js";
+import { Identity } from "../../../domain/identity/Identity.js";
+class CreateFileUseCaseImpl {
+  constructor(identityContext, filePermissions, repository, getSettings, eventPublisher) {
+    this.identityContext = identityContext;
+    this.filePermissions = filePermissions;
+    this.repository = repository;
+    this.getSettings = getSettings;
+    this.eventPublisher = eventPublisher;
+  }
+  async execute(input, meta) {
+    const hasPermission = await this.filePermissions.ensure({
+      rwd: "w"
+    });
+    if (!hasPermission) {
+      return Result.fail(new FileNotAuthorizedError());
+    }
+    const validationResult = await this.validateInput(input);
+    if (validationResult.isFail()) {
+      return Result.fail(validationResult.error);
+    }
+    const [id] = input.key.split("/");
+    const currentIdentity = this.identityContext.getIdentity();
+
+    // Prepare file input
+    const fileInput = {
+      id: input.id || id,
+      key: input.key,
+      name: input.name,
+      size: input.size,
+      type: input.type,
+      metadata: input.metadata || {},
+      location: input.location || {
+        folderId: "root"
+      },
+      tags: input.tags || [],
+      extensions: meta || {},
+      // system attributes
+      createdOn: input.createdOn,
+      modifiedOn: input.modifiedOn,
+      savedOn: input.savedOn,
+      createdBy: input.createdBy ? Identity.from(input.createdBy) : Identity.from(currentIdentity),
+      modifiedBy: input.modifiedBy ? Identity.from(input.modifiedBy) : undefined,
+      savedBy: input.savedBy ? Identity.from(input.savedBy) : Identity.from(currentIdentity)
+    };
+    await this.eventPublisher.publish(new FileBeforeCreateEvent({
+      file: fileInput,
+      meta
+    }));
+    const result = await this.repository.execute(fileInput);
+    if (result.isFail()) {
+      return Result.fail(result.error);
+    }
+    await this.eventPublisher.publish(new FileAfterCreateEvent({
+      file: result.value,
+      meta
+    }));
+    return Result.ok(result.value);
+  }
+  async validateInput(input) {
+    const settingsResult = await this.getSettings.execute();
+    if (settingsResult.isFail()) {
+      return Result.ok();
+    }
+    const settings = settingsResult.value;
+    if (settings) {
+      // Validate file size
+      if (input.size < settings.uploadMinFileSize || input.size > settings.uploadMaxFileSize) {
+        return Result.fail(new InvalidFileSizeError({
+          size: input.size,
+          minSize: settings.uploadMinFileSize,
+          maxSize: settings.uploadMaxFileSize
+        }));
+      }
+    }
+    return Result.ok();
+  }
+}
+export const CreateFileUseCase = UseCaseAbstraction.createImplementation({
+  implementation: CreateFileUseCaseImpl,
+  dependencies: [IdentityContext, FilePermissions, CreateFileRepository, GetSettingsUseCase, EventPublisher]
+});
+
+//# sourceMappingURL=CreateFileUseCase.js.map

package/features/file/CreateFile/CreateFileUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["Result","CreateFileUseCase","UseCaseAbstraction","CreateFileRepository","GetSettingsUseCase","EventPublisher","FileNotAuthorizedError","InvalidFileSizeError","FileBeforeCreateEvent","FileAfterCreateEvent","FilePermissions","IdentityContext","Identity","CreateFileUseCaseImpl","constructor","identityContext","filePermissions","repository","getSettings","eventPublisher","execute","input","meta","hasPermission","ensure","rwd","fail","validationResult","validateInput","isFail","error","id","key","split","currentIdentity","getIdentity","fileInput","name","size","type","metadata","location","folderId","tags","extensions","createdOn","modifiedOn","savedOn","createdBy","from","modifiedBy","undefined","savedBy","publish","file","result","value","ok","settingsResult","settings","uploadMinFileSize","uploadMaxFileSize","minSize","maxSize","createImplementation","implementation","dependencies"],"sources":["CreateFileUseCase.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport {\n    CreateFileUseCase as UseCaseAbstraction,\n    CreateFileInput,\n    CreateFileRepository\n} from \"./abstractions.js\";\nimport { GetSettingsUseCase } from \"../../settings/GetSettings/abstractions.js\";\nimport { EventPublisher } from \"@webiny/api-core/features/EventPublisher\";\nimport type { File, FileInput } from \"~/domain/file/types.js\";\nimport { FileNotAuthorizedError, InvalidFileSizeError } from \"~/domain/file/errors.js\";\nimport { FileBeforeCreateEvent, FileAfterCreateEvent } from \"./events.js\";\nimport { FilePermissions } from \"~/features/shared/abstractions.js\";\nimport { IdentityContext } from \"@webiny/api-core/features/security/IdentityContext/index.js\";\nimport { Identity } from \"~/domain/identity/Identity.js\";\n\nclass CreateFileUseCaseImpl implements UseCaseAbstraction.Interface {\n    constructor(\n        private identityContext: IdentityContext.Interface,\n        private filePermissions: FilePermissions.Interface,\n        private repository: CreateFileRepository.Interface,\n        private getSettings: GetSettingsUseCase.Interface,\n        private eventPublisher: EventPublisher.Interface\n    ) {}\n\n    async execute(\n        input: CreateFileInput,\n        meta?: Record<string, any>\n    ): Promise<Result<File, UseCaseAbstraction.Error>> {\n        const hasPermission = await this.filePermissions.ensure({ rwd: \"w\" });\n        if (!hasPermission) {\n            return Result.fail(new FileNotAuthorizedError());\n        }\n\n        const validationResult = await this.validateInput(input);\n        if (validationResult.isFail()) {\n            return Result.fail(validationResult.error);\n        }\n\n        const [id] = input.key.split(\"/\");\n        const currentIdentity = this.identityContext.getIdentity();\n\n        // Prepare file input\n        const fileInput: FileInput = {\n            id: input.id || id,\n            key: input.key,\n            name: input.name,\n            size: input.size,\n            type: input.type,\n            metadata: input.metadata || {},\n            location: input.location || { folderId: \"root\" },\n            tags: input.tags || [],\n            extensions: meta || {},\n            // system attributes\n            createdOn: input.createdOn,\n            modifiedOn: input.modifiedOn,\n            savedOn: input.savedOn,\n            createdBy: input.createdBy\n                ? Identity.from(input.createdBy)\n                : Identity.from(currentIdentity),\n            modifiedBy: input.modifiedBy ? Identity.from(input.modifiedBy) : undefined,\n            savedBy: input.savedBy ? Identity.from(input.savedBy) : Identity.from(currentIdentity)\n        };\n\n        await this.eventPublisher.publish(new FileBeforeCreateEvent({ file: fileInput, meta }));\n\n        const result = await this.repository.execute(fileInput);\n\n        if (result.isFail()) {\n            return Result.fail(result.error);\n        }\n\n        await this.eventPublisher.publish(new FileAfterCreateEvent({ file: result.value, meta }));\n\n        return Result.ok(result.value);\n    }\n\n    private async validateInput(\n        input: CreateFileInput\n    ): Promise<Result<void, InvalidFileSizeError>> {\n        const settingsResult = await this.getSettings.execute();\n\n        if (settingsResult.isFail()) {\n            return Result.ok();\n        }\n\n        const settings = settingsResult.value;\n\n        if (settings) {\n            // Validate file size\n            if (\n                input.size < settings.uploadMinFileSize ||\n                input.size > settings.uploadMaxFileSize\n            ) {\n                return Result.fail(\n                    new InvalidFileSizeError({\n                        size: input.size,\n                        minSize: settings.uploadMinFileSize,\n                        maxSize: settings.uploadMaxFileSize\n                    })\n                );\n            }\n        }\n\n        return Result.ok();\n    }\n}\n\nexport const CreateFileUseCase = UseCaseAbstraction.createImplementation({\n    implementation: CreateFileUseCaseImpl,\n    dependencies: [\n        IdentityContext,\n        FilePermissions,\n        CreateFileRepository,\n        GetSettingsUseCase,\n        EventPublisher\n    ]\n});\n"],"mappings":"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","ignoreList":[]}

package/features/file/CreateFile/abstractions.d.ts

@@ -0,0 +1,57 @@
+import type { Result } from "@webiny/feature/api";
+import type { CreatedBy, File, FileInput } from "../../../domain/file/types.js";
+import { type FilePersistenceError, type InvalidFileSizeError, type FileAlreadyExistsError, FileNotAuthorizedError } from "../../../domain/file/errors.js";
+export interface CreateFileInput {
+    id?: string;
+    key: string;
+    size: number;
+    type: string;
+    name: string;
+    metadata?: Record<string, any>;
+    extensions?: Record<string, any>;
+    tags?: string[];
+    location?: {
+        folderId: string;
+    };
+    createdOn?: string;
+    createdBy?: CreatedBy;
+    modifiedOn?: string;
+    modifiedBy?: CreatedBy;
+    savedOn?: string;
+    savedBy?: CreatedBy;
+}
+/**
+ * CreateFile repository interface
+ */
+export interface ICreateFileRepository {
+    execute(data: FileInput): Promise<Result<File, RepositoryError>>;
+}
+export interface ICreateFileRepositoryErrors {
+    notAuthorized: FileNotAuthorizedError;
+    persistence: FilePersistenceError;
+}
+type RepositoryError = ICreateFileRepositoryErrors[keyof ICreateFileRepositoryErrors];
+export declare const CreateFileRepository: import("@webiny/di").Abstraction<ICreateFileRepository>;
+export declare namespace CreateFileRepository {
+    type Interface = ICreateFileRepository;
+    type Error = RepositoryError;
+}
+/**
+ * CreateFile use case interface
+ */
+export interface ICreateFileUseCase {
+    execute(input: CreateFileInput, meta?: Record<string, any>): Promise<Result<File, UseCaseError>>;
+}
+export interface ICreateFileUseCaseErrors {
+    notAuthorized: FileNotAuthorizedError;
+    persistence: FilePersistenceError;
+    invalidSize: InvalidFileSizeError;
+    alreadyExists: FileAlreadyExistsError;
+}
+type UseCaseError = ICreateFileUseCaseErrors[keyof ICreateFileUseCaseErrors];
+export declare const CreateFileUseCase: import("@webiny/di").Abstraction<ICreateFileUseCase>;
+export declare namespace CreateFileUseCase {
+    type Interface = ICreateFileUseCase;
+    type Error = UseCaseError;
+}
+export {};

package/features/file/CreateFile/abstractions.js

@@ -0,0 +1,15 @@
+import { createAbstraction } from "@webiny/feature/api";
+
+/**
+ * CreateFile repository interface
+ */
+
+export const CreateFileRepository = createAbstraction("CreateFileRepository");
+
+/**
+ * CreateFile use case interface
+ */
+
+export const CreateFileUseCase = createAbstraction("CreateFileUseCase");
+
+//# sourceMappingURL=abstractions.js.map

package/features/file/CreateFile/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["createAbstraction","CreateFileRepository","CreateFileUseCase"],"sources":["abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type { Result } from \"@webiny/feature/api\";\nimport type { CreatedBy, File, FileInput } from \"~/domain/file/types.js\";\nimport {\n    type FilePersistenceError,\n    type InvalidFileSizeError,\n    type FileAlreadyExistsError,\n    FileNotAuthorizedError\n} from \"~/domain/file/errors.js\";\n\nexport interface CreateFileInput {\n    id?: string;\n    key: string;\n    size: number;\n    type: string;\n    name: string;\n    metadata?: Record<string, any>;\n    extensions?: Record<string, any>;\n    tags?: string[];\n    location?: { folderId: string };\n    // System attributes\n    createdOn?: string;\n    createdBy?: CreatedBy;\n    modifiedOn?: string;\n    modifiedBy?: CreatedBy;\n    savedOn?: string;\n    savedBy?: CreatedBy;\n}\n\n/**\n * CreateFile repository interface\n */\nexport interface ICreateFileRepository {\n    execute(data: FileInput): Promise<Result<File, RepositoryError>>;\n}\n\nexport interface ICreateFileRepositoryErrors {\n    notAuthorized: FileNotAuthorizedError;\n    persistence: FilePersistenceError;\n}\n\ntype RepositoryError = ICreateFileRepositoryErrors[keyof ICreateFileRepositoryErrors];\n\nexport const CreateFileRepository =\n    createAbstraction<ICreateFileRepository>(\"CreateFileRepository\");\n\nexport namespace CreateFileRepository {\n    export type Interface = ICreateFileRepository;\n    export type Error = RepositoryError;\n}\n\n/**\n * CreateFile use case interface\n */\nexport interface ICreateFileUseCase {\n    execute(\n        input: CreateFileInput,\n        meta?: Record<string, any>\n    ): Promise<Result<File, UseCaseError>>;\n}\n\nexport interface ICreateFileUseCaseErrors {\n    notAuthorized: FileNotAuthorizedError;\n    persistence: FilePersistenceError;\n    invalidSize: InvalidFileSizeError;\n    alreadyExists: FileAlreadyExistsError;\n}\n\ntype UseCaseError = ICreateFileUseCaseErrors[keyof ICreateFileUseCaseErrors];\n\nexport const CreateFileUseCase = createAbstraction<ICreateFileUseCase>(\"CreateFileUseCase\");\n\nexport namespace CreateFileUseCase {\n    export type Interface = ICreateFileUseCase;\n    export type Error = UseCaseError;\n}\n"],"mappings":"AAAA,SAASA,iBAAiB,QAAQ,qBAAqB;;AA6BvD;AACA;AACA;;AAYA,OAAO,MAAMC,oBAAoB,GAC7BD,iBAAiB,CAAwB,sBAAsB,CAAC;;AAOpE;AACA;AACA;;AAiBA,OAAO,MAAME,iBAAiB,GAAGF,iBAAiB,CAAqB,mBAAmB,CAAC","ignoreList":[]}