@webiny/api-file-manager 0.0.0-unstable.eb196ccd2f → 0.0.0-unstable.eb81deee7e

package/features/upload/utils/FileNormalizer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/upload/utils/FileNormalizer.js","sources":["../../../../src/features/upload/utils/FileNormalizer.ts"],"sourcesContent":["import { mdbid } from \"@webiny/utils\";\nimport type { FileData, PresignedPostPayloadData } from \"~/features/upload/types.js\";\nimport { FileKey } from \"./FileKey.js\";\nimport { mimeTypes } from \"./mimeTypes.js\";\nimport type { FileModifier } from \"./FileUploadModifier.js\";\n\nexport interface FileToSign {\n    name: string;\n    key: string;\n    type: string;\n    size: number;\n}\n\nconst extensionToMime = new Map<string, string>();\nfor (const [mime, extensions] of Object.entries(mimeTypes)) {\n    for (const ext of extensions) {\n        if (!extensionToMime.has(ext)) {\n            extensionToMime.set(ext, mime);\n        }\n    }\n}\n\nfunction resolveTypeFromName(name: string): string {\n    const ext = name.slice(name.lastIndexOf(\".\") + 1).toLowerCase();\n    return extensionToMime.get(ext) || \"application/octet-stream\";\n}\n\n/*\n * FileNormalizer normalizes file data, before it's signed for upload.\n * It generates a unique file id, and makes sure that the file key includes the unique id.\n */\nexport class FileNormalizer {\n    private readonly modifier: FileModifier | undefined;\n\n    constructor(modifier?: FileModifier) {\n        this.modifier = modifier;\n    }\n\n    async normalizeFile(payload: PresignedPostPayloadData): Promise<FileData> {\n        const data = {\n            ...payload,\n            id: payload.id || mdbid(),\n            type: payload.type || resolveTypeFromName(payload.name)\n        };\n\n        const key = new FileKey(data);\n        const defaultKey = key.toString();\n\n        const file: FileToSign = {\n            name: data.name,\n            type: data.type,\n            key: defaultKey,\n            size: data.size\n        };\n\n        if (this.modifier) {\n            Object.assign(file, await this.modifier(file));\n        }\n\n        if (defaultKey !== file.key) {\n            key.setKey(file.key);\n        }\n\n        return {\n            id: data.id,\n            key: key.toString(),\n            name: file.name,\n            size: file.size,\n            type: file.type\n        };\n    }\n}\n"],"names":["extensionToMime","Map","mime","extensions","Object","mimeTypes","ext","resolveTypeFromName","name","FileNormalizer","modifier","payload","data","mdbid","key","FileKey","defaultKey","file"],"mappings":";;;AAaA,MAAMA,kBAAkB,IAAIC;AAC5B,KAAK,MAAM,CAACC,MAAMC,WAAW,IAAIC,OAAO,OAAO,CAACC,iCAC5C,KAAK,MAAMC,OAAOH,WACd,IAAI,CAACH,gBAAgB,GAAG,CAACM,MACrBN,gBAAgB,GAAG,CAACM,KAAKJ;AAKrC,SAASK,oBAAoBC,IAAY;IACrC,MAAMF,MAAME,KAAK,KAAK,CAACA,KAAK,WAAW,CAAC,OAAO,GAAG,WAAW;IAC7D,OAAOR,gBAAgB,GAAG,CAACM,QAAQ;AACvC;AAMO,MAAMG;IAGT,YAAYC,QAAuB,CAAE;QACjC,IAAI,CAAC,QAAQ,GAAGA;IACpB;IAEA,MAAM,cAAcC,OAAiC,EAAqB;QACtE,MAAMC,OAAO;YACT,GAAGD,OAAO;YACV,IAAIA,QAAQ,EAAE,IAAIE;YAClB,MAAMF,QAAQ,IAAI,IAAIJ,oBAAoBI,QAAQ,IAAI;QAC1D;QAEA,MAAMG,MAAM,IAAIC,QAAQH;QACxB,MAAMI,aAAaF,IAAI,QAAQ;QAE/B,MAAMG,OAAmB;YACrB,MAAML,KAAK,IAAI;YACf,MAAMA,KAAK,IAAI;YACf,KAAKI;YACL,MAAMJ,KAAK,IAAI;QACnB;QAEA,IAAI,IAAI,CAAC,QAAQ,EACbR,OAAO,MAAM,CAACa,MAAM,MAAM,IAAI,CAAC,QAAQ,CAACA;QAG5C,IAAID,eAAeC,KAAK,GAAG,EACvBH,IAAI,MAAM,CAACG,KAAK,GAAG;QAGvB,OAAO;YACH,IAAIL,KAAK,EAAE;YACX,KAAKE,IAAI,QAAQ;YACjB,MAAMG,KAAK,IAAI;YACf,MAAMA,KAAK,IAAI;YACf,MAAMA,KAAK,IAAI;QACnB;IACJ;AACJ"}

package/features/upload/utils/FileUploadModifier.d.ts

@@ -0,0 +1,30 @@
+import { Plugin } from "@webiny/plugins";
+import type { FileToSign } from "./FileNormalizer.js";
+interface Setter<T> {
+    (param: T): T;
+}
+declare class FileUploadModifier {
+    private fileSetters;
+    setFile(setter: Setter<FileToSign>): void;
+    execute(file: FileToSign): Promise<FileToSign>;
+}
+interface FileUploadModifierCallbackParams {
+    modifier: {
+        setFile: FileUploadModifier["setFile"];
+    };
+}
+export declare class FileUploadModifierPlugin extends Plugin {
+    static type: string;
+    private readonly cb;
+    constructor(cb: FileUploadModifierCallable);
+    execute(params: FileUploadModifierCallbackParams): void;
+}
+interface FileUploadModifierCallable {
+    (params: FileUploadModifierCallbackParams): void;
+}
+export declare const createFileUploadModifier: (cb: FileUploadModifierCallable) => FileUploadModifierPlugin;
+export interface FileModifier {
+    (file: FileToSign): Promise<Partial<FileToSign>> | Partial<FileToSign>;
+}
+export declare const createModifierFromPlugins: (plugins?: FileUploadModifierPlugin[]) => FileModifier;
+export {};

package/features/upload/utils/FileUploadModifier.js

@@ -0,0 +1,39 @@
+import p_reduce from "p-reduce";
+import { Plugin } from "@webiny/plugins";
+class FileUploadModifier {
+    setFile(setter) {
+        this.fileSetters.push(setter);
+    }
+    execute(file) {
+        return p_reduce(this.fileSetters, async (file, setter)=>({
+                ...file,
+                ...await setter(file)
+            }), file);
+    }
+    constructor(){
+        this.fileSetters = [];
+    }
+}
+class FileUploadModifierPlugin extends Plugin {
+    static{
+        this.type = "fm.uploadModifier";
+    }
+    constructor(cb){
+        super();
+        this.cb = cb;
+    }
+    execute(params) {
+        return this.cb(params);
+    }
+}
+const createFileUploadModifier = (cb)=>new FileUploadModifierPlugin(cb);
+const createModifierFromPlugins = (plugins = [])=>{
+    const modifier = new FileUploadModifier();
+    plugins.forEach((pl)=>pl.execute({
+            modifier
+        }));
+    return (file)=>modifier.execute(file);
+};
+export { FileUploadModifierPlugin, createFileUploadModifier, createModifierFromPlugins };
+
+//# sourceMappingURL=FileUploadModifier.js.map

package/features/upload/utils/FileUploadModifier.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/upload/utils/FileUploadModifier.js","sources":["../../../../src/features/upload/utils/FileUploadModifier.ts"],"sourcesContent":["import pReduce from \"p-reduce\";\nimport { Plugin } from \"@webiny/plugins\";\nimport type { FileToSign } from \"./FileNormalizer.js\";\n\ninterface Setter<T> {\n    (param: T): T;\n}\n\nclass FileUploadModifier {\n    private fileSetters: Setter<FileToSign>[] = [];\n\n    setFile(setter: Setter<FileToSign>): void {\n        this.fileSetters.push(setter);\n    }\n\n    execute(file: FileToSign) {\n        return pReduce(\n            this.fileSetters,\n            async (file, setter) => {\n                /* We need to spread the original file, then add (potentially) partial changes. */\n                return { ...file, ...(await setter(file)) };\n            },\n            file\n        );\n    }\n}\n\ninterface FileUploadModifierCallbackParams {\n    modifier: {\n        setFile: FileUploadModifier[\"setFile\"];\n    };\n}\n\nexport class FileUploadModifierPlugin extends Plugin {\n    public static override type = \"fm.uploadModifier\";\n    private readonly cb: FileUploadModifierCallable;\n\n    constructor(cb: FileUploadModifierCallable) {\n        super();\n        this.cb = cb;\n    }\n\n    execute(params: FileUploadModifierCallbackParams) {\n        return this.cb(params);\n    }\n}\n\ninterface FileUploadModifierCallable {\n    (params: FileUploadModifierCallbackParams): void;\n}\n\nexport const createFileUploadModifier = (cb: FileUploadModifierCallable) => {\n    return new FileUploadModifierPlugin(cb);\n};\n\nexport interface FileModifier {\n    (file: FileToSign): Promise<Partial<FileToSign>> | Partial<FileToSign>;\n}\n\nexport const createModifierFromPlugins = (\n    plugins: FileUploadModifierPlugin[] = []\n): FileModifier => {\n    const modifier = new FileUploadModifier();\n    plugins.forEach(pl => pl.execute({ modifier }));\n\n    return (file: FileToSign) => modifier.execute(file);\n};\n"],"names":["FileUploadModifier","setter","file","pReduce","FileUploadModifierPlugin","Plugin","cb","params","createFileUploadModifier","createModifierFromPlugins","plugins","modifier","pl"],"mappings":";;AAQA,MAAMA;IAGF,QAAQC,MAA0B,EAAQ;QACtC,IAAI,CAAC,WAAW,CAAC,IAAI,CAACA;IAC1B;IAEA,QAAQC,IAAgB,EAAE;QACtB,OAAOC,SACH,IAAI,CAAC,WAAW,EAChB,OAAOD,MAAMD,SAEF;gBAAE,GAAGC,IAAI;gBAAE,GAAI,MAAMD,OAAOC,KAAK;YAAE,IAE9CA;IAER;;aAfQ,WAAW,GAAyB,EAAE;;AAgBlD;AAQO,MAAME,iCAAiCC;;aACnB,IAAI,GAAG;;IAG9B,YAAYC,EAA8B,CAAE;QACxC,KAAK;QACL,IAAI,CAAC,EAAE,GAAGA;IACd;IAEA,QAAQC,MAAwC,EAAE;QAC9C,OAAO,IAAI,CAAC,EAAE,CAACA;IACnB;AACJ;AAMO,MAAMC,2BAA2B,CAACF,KAC9B,IAAIF,yBAAyBE;AAOjC,MAAMG,4BAA4B,CACrCC,UAAsC,EAAE;IAExC,MAAMC,WAAW,IAAIX;IACrBU,QAAQ,OAAO,CAACE,CAAAA,KAAMA,GAAG,OAAO,CAAC;YAAED;QAAS;IAE5C,OAAO,CAACT,OAAqBS,SAAS,OAAO,CAACT;AAClD"}

package/features/upload/utils/checkPermissions.d.ts

@@ -0,0 +1,5 @@
+import type { FilePermission } from "../../../types.js";
+import { IdentityContext } from "@webiny/api-core/features/security/IdentityContext/index.js";
+export declare const checkPermissions: (identityContext: IdentityContext.Interface, check?: {
+    rwd?: string;
+}) => Promise<FilePermission[]>;

package/features/upload/utils/checkPermissions.js

@@ -0,0 +1,22 @@
+import { NotAuthorizedError } from "@webiny/api-core/features/security/shared/index.js";
+const checkPermissions = async (identityContext, check = {})=>{
+    const filePermissions = await identityContext.getPermissions("fm.file");
+    const relevantFilePermissions = filePermissions.filter((current)=>{
+        if (check.rwd && !hasRwd(current, check.rwd)) return false;
+        return true;
+    });
+    if (0 === relevantFilePermissions.length) throw new NotAuthorizedError();
+    return relevantFilePermissions;
+};
+const hasRwd = (filesFilePermissions, rwd)=>{
+    if (!Array.isArray(filesFilePermissions)) filesFilePermissions = [
+        filesFilePermissions
+    ];
+    if (!rwd) return true;
+    const permissionWithoutRwdRestrictions = filesFilePermissions.some((permission)=>"string" != typeof permission.rwd);
+    if (permissionWithoutRwdRestrictions) return true;
+    return filesFilePermissions.some((permission)=>permission.rwd && permission.rwd.includes(rwd));
+};
+export { checkPermissions };
+
+//# sourceMappingURL=checkPermissions.js.map

package/features/upload/utils/checkPermissions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/upload/utils/checkPermissions.js","sources":["../../../../src/features/upload/utils/checkPermissions.ts"],"sourcesContent":["import type { FilePermission } from \"~/types.js\";\nimport { NotAuthorizedError } from \"@webiny/api-core/features/security/shared/index.js\";\nimport { IdentityContext } from \"@webiny/api-core/features/security/IdentityContext/index.js\";\n\nexport const checkPermissions = async (\n    identityContext: IdentityContext.Interface,\n    check: { rwd?: string } = {}\n) => {\n    const filePermissions = await identityContext.getPermissions<FilePermission>(\"fm.file\");\n\n    const relevantFilePermissions = filePermissions.filter(current => {\n        if (check.rwd && !hasRwd(current, check.rwd)) {\n            return false;\n        }\n\n        return true;\n    });\n\n    if (relevantFilePermissions.length === 0) {\n        throw new NotAuthorizedError();\n    }\n\n    return relevantFilePermissions;\n};\n\nconst hasRwd = (filesFilePermissions: FilePermission | FilePermission[], rwd: string): boolean => {\n    if (!Array.isArray(filesFilePermissions)) {\n        filesFilePermissions = [filesFilePermissions];\n    }\n\n    if (!rwd) {\n        return true;\n    }\n\n    /* Is there a permission that doesn't restrict RWD, all RWD permissions are allowed. */\n    const permissionWithoutRwdRestrictions = filesFilePermissions.some(permission => {\n        return typeof permission.rwd !== \"string\";\n    });\n\n    if (permissionWithoutRwdRestrictions) {\n        return true;\n    }\n\n    return filesFilePermissions.some(permission => {\n        return permission.rwd && permission.rwd.includes(rwd);\n    });\n};\n"],"names":["checkPermissions","identityContext","check","filePermissions","relevantFilePermissions","current","hasRwd","NotAuthorizedError","filesFilePermissions","rwd","Array","permissionWithoutRwdRestrictions","permission"],"mappings":";AAIO,MAAMA,mBAAmB,OAC5BC,iBACAC,QAA0B,CAAC,CAAC;IAE5B,MAAMC,kBAAkB,MAAMF,gBAAgB,cAAc,CAAiB;IAE7E,MAAMG,0BAA0BD,gBAAgB,MAAM,CAACE,CAAAA;QACnD,IAAIH,MAAM,GAAG,IAAI,CAACI,OAAOD,SAASH,MAAM,GAAG,GACvC,OAAO;QAGX,OAAO;IACX;IAEA,IAAIE,AAAmC,MAAnCA,wBAAwB,MAAM,EAC9B,MAAM,IAAIG;IAGd,OAAOH;AACX;AAEA,MAAME,SAAS,CAACE,sBAAyDC;IACrE,IAAI,CAACC,MAAM,OAAO,CAACF,uBACfA,uBAAuB;QAACA;KAAqB;IAGjD,IAAI,CAACC,KACD,OAAO;IAIX,MAAME,mCAAmCH,qBAAqB,IAAI,CAACI,CAAAA,aACxD,AAA0B,YAA1B,OAAOA,WAAW,GAAG;IAGhC,IAAID,kCACA,OAAO;IAGX,OAAOH,qBAAqB,IAAI,CAACI,CAAAA,aACtBA,WAAW,GAAG,IAAIA,WAAW,GAAG,CAAC,QAAQ,CAACH;AAEzD"}

package/features/upload/utils/createFileNormalizerFromContext.d.ts

@@ -0,0 +1,3 @@
+import type { Context } from "@webiny/api/types.js";
+import { FileNormalizer } from "./FileNormalizer.js";
+export declare const createFileNormalizerFromContext: (context: Context) => FileNormalizer;

package/features/upload/utils/createFileNormalizerFromContext.js

@@ -0,0 +1,9 @@
+import { FileNormalizer } from "./FileNormalizer.js";
+import { FileUploadModifierPlugin, createModifierFromPlugins } from "./FileUploadModifier.js";
+const createFileNormalizerFromContext = (context)=>{
+    const modifierPlugins = context.plugins.byType(FileUploadModifierPlugin.type);
+    return new FileNormalizer(createModifierFromPlugins(modifierPlugins));
+};
+export { createFileNormalizerFromContext };
+
+//# sourceMappingURL=createFileNormalizerFromContext.js.map

package/features/upload/utils/createFileNormalizerFromContext.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/upload/utils/createFileNormalizerFromContext.js","sources":["../../../../src/features/upload/utils/createFileNormalizerFromContext.ts"],"sourcesContent":["import type { Context } from \"@webiny/api/types.js\";\nimport { FileNormalizer } from \"./FileNormalizer.js\";\nimport { createModifierFromPlugins } from \"./FileUploadModifier.js\";\nimport { FileUploadModifierPlugin } from \"./FileUploadModifier.js\";\n\nexport const createFileNormalizerFromContext = (context: Context) => {\n    const modifierPlugins = context.plugins.byType<FileUploadModifierPlugin>(\n        FileUploadModifierPlugin.type\n    );\n\n    return new FileNormalizer(createModifierFromPlugins(modifierPlugins));\n};\n"],"names":["createFileNormalizerFromContext","context","modifierPlugins","FileUploadModifierPlugin","FileNormalizer","createModifierFromPlugins"],"mappings":";;AAKO,MAAMA,kCAAkC,CAACC;IAC5C,MAAMC,kBAAkBD,QAAQ,OAAO,CAAC,MAAM,CAC1CE,yBAAyB,IAAI;IAGjC,OAAO,IAAIC,eAAeC,0BAA0BH;AACxD"}

package/features/upload/utils/mimeTypes.d.ts

@@ -0,0 +1 @@
+export declare const mimeTypes: Record<string, string[]>;

package/features/upload/utils/mimeTypes.js

@@ -0,0 +1,9 @@
+import other from "mime/types/other.js";
+import standard from "mime/types/standard.js";
+const mimeTypes_mimeTypes = {
+    ...other,
+    ...standard
+};
+export { mimeTypes_mimeTypes as mimeTypes };
+
+//# sourceMappingURL=mimeTypes.js.map

package/features/upload/utils/mimeTypes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/upload/utils/mimeTypes.js","sources":["../../../../src/features/upload/utils/mimeTypes.ts"],"sourcesContent":["import vendorTypes from \"mime/types/other.js\";\nimport standardTypes from \"mime/types/standard.js\";\n\n/*\n * We need to get all extensions that are defined for a specific content type.\n * This operation is not available via the `mime` package, so we create such an object ourselves.\n */\nexport const mimeTypes: Record<string, string[]> = {\n    ...vendorTypes,\n    ...standardTypes\n};\n"],"names":["mimeTypes","vendorTypes","standardTypes"],"mappings":";;AAOO,MAAMA,sBAAsC;IAC/C,GAAGC,KAAW;IACd,GAAGC,QAAa;AACpB"}

package/graphql/FmGraphQLSchema.d.ts

@@ -0,0 +1,24 @@
+import { GraphQLSchemaFactory } from "@webiny/api-graphql/graphql/abstractions.js";
+import { ListModelsUseCase } from "@webiny/api-headless-cms/features/contentModel/ListModels/index.js";
+import { CmsModelFieldToGraphQLRegistry } from "@webiny/api-headless-cms/exports/api/cms/graphql.js";
+import { IdentityContext } from "@webiny/api-core/exports/api/security.js";
+import { FileModelProvider } from "../domain/file/abstractions.js";
+declare class FmGraphQLSchema_ implements GraphQLSchemaFactory.Interface {
+    private readonly identityContext;
+    private readonly listModelsUseCase;
+    private readonly fieldRegistry;
+    private readonly fileModelProvider;
+    constructor(identityContext: IdentityContext.Interface, listModelsUseCase: ListModelsUseCase.Interface, fieldRegistry: CmsModelFieldToGraphQLRegistry.Interface, fileModelProvider: FileModelProvider.Interface);
+    getSchemaKey(): Promise<string>;
+    execute(builder: GraphQLSchemaFactory.SchemaBuilder): Promise<GraphQLSchemaFactory.SchemaBuilder>;
+    private addBaseTypeDefs;
+    private addFileTypeDefs;
+    private addSettingsResolvers;
+    private addFileQueryResolvers;
+    private addFileMutationResolvers;
+    private loadModels;
+}
+export declare const FmGraphQLSchema: typeof FmGraphQLSchema_ & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-graphql/graphql/abstractions.public").IGraphQLSchemaFactory>;
+};
+export {};

package/graphql/FmGraphQLSchema.js

@@ -0,0 +1,458 @@
+import { GraphQLSchemaFactory } from "@webiny/api-graphql/graphql/abstractions.js";
+import { createModelSchemaKey } from "@webiny/api-headless-cms/utils/createModelSchemaKey.js";
+import { ErrorResponse, ListResponse, NotFoundResponse, Response } from "@webiny/api-graphql";
+import { renderFields } from "@webiny/api-headless-cms/utils/renderFields.js";
+import { renderInputFields } from "@webiny/api-headless-cms/utils/renderInputFields.js";
+import { renderListFilterFields } from "@webiny/api-headless-cms/utils/renderListFilterFields.js";
+import { ListModelsUseCase } from "@webiny/api-headless-cms/features/contentModel/ListModels/index.js";
+import { CmsModelFieldToGraphQLRegistry } from "@webiny/api-headless-cms/exports/api/cms/graphql.js";
+import { IdentityContext } from "@webiny/api-core/exports/api/security.js";
+import { GetFileUseCase } from "../features/file/GetFile/abstractions.js";
+import { ListFilesUseCase } from "../features/file/ListFiles/abstractions.js";
+import { ListTagsUseCase } from "../features/file/ListTags/abstractions.js";
+import { CreateFileUseCase } from "../features/file/CreateFile/abstractions.js";
+import { CreateFilesInBatchUseCase } from "../features/file/CreateFilesInBatch/abstractions.js";
+import { UpdateFileUseCase } from "../features/file/UpdateFile/abstractions.js";
+import { DeleteFileUseCase } from "../features/file/DeleteFile/abstractions.js";
+import { GetFileByUrlUseCase } from "../features/file/GetFileByUrl/abstractions.js";
+import { GetSettingsUseCase } from "../features/settings/GetSettings/abstractions.js";
+import { UpdateSettingsUseCase } from "../features/settings/UpdateSettings/abstractions.js";
+import { FileUrlGenerator } from "../features/file/FileUrlGenerator/abstractions.js";
+import { FileModelProvider } from "../domain/file/abstractions.js";
+const removeFieldRequiredValidation = (field)=>{
+    if (field.validation) field.validation = field.validation.filter((validation)=>"required" !== validation.name);
+    if (field.listValidation) field.listValidation = field.listValidation.filter((v)=>"required" !== v.name);
+    return field;
+};
+const createUpdateFields = (fields)=>fields.reduce((collection, field)=>{
+        collection.push(removeFieldRequiredValidation({
+            ...field
+        }));
+        return collection;
+    }, []);
+class FmGraphQLSchema_ {
+    constructor(identityContext, listModelsUseCase, fieldRegistry, fileModelProvider){
+        this.identityContext = identityContext;
+        this.listModelsUseCase = listModelsUseCase;
+        this.fieldRegistry = fieldRegistry;
+        this.fileModelProvider = fileModelProvider;
+    }
+    async getSchemaKey() {
+        const models = await this.loadModels();
+        const fileModel = await this.fileModelProvider.get();
+        const modelKey = createModelSchemaKey([
+            fileModel
+        ], models);
+        return `FileManager:${modelKey}`;
+    }
+    async execute(builder) {
+        this.addBaseTypeDefs(builder);
+        await this.addFileTypeDefs(builder);
+        this.addSettingsResolvers(builder);
+        this.addFileQueryResolvers(builder);
+        this.addFileMutationResolvers(builder);
+        return builder;
+    }
+    addBaseTypeDefs(builder) {
+        builder.addTypeDefs(`
+            type FmError {
+                code: String
+                message: String
+                data: JSON
+                stack: String
+            }
+
+            type FmCreatedBy {
+                id: ID
+                displayName: String
+                type: String
+            }
+
+            type FmListMeta {
+                cursor: String
+                totalCount: Int
+                hasMoreItems: Boolean
+            }
+
+            type FmBooleanResponse {
+                data: Boolean
+                error: FmError
+            }
+
+            type FmSettings {
+                uploadMinFileSize: Number
+                uploadMaxFileSize: Number
+                srcPrefix: String
+            }
+
+            input FmSettingsInput {
+                uploadMinFileSize: Number
+                uploadMaxFileSize: Number
+                srcPrefix: String
+            }
+
+            type FmSettingsResponse {
+                data: FmSettings
+                error: FmError
+            }
+
+            type FmDeleteResponse {
+                data: Boolean
+                error: FmError
+            }
+
+            type FmQuery {
+                getSettings: FmSettingsResponse
+            }
+
+            type FmMutation {
+                updateSettings(data: FmSettingsInput): FmSettingsResponse
+            }
+
+            extend type Query {
+                fileManager: FmQuery
+            }
+
+            extend type Mutation {
+                fileManager: FmMutation
+            }
+        `);
+        builder.addResolver({
+            path: "Query.fileManager",
+            resolver: ()=>()=>({})
+        });
+        builder.addResolver({
+            path: "Mutation.fileManager",
+            resolver: ()=>()=>({})
+        });
+    }
+    async addFileTypeDefs(builder) {
+        const models = await this.loadModels();
+        const fileModel = await this.fileModelProvider.get();
+        const { fields } = fileModel;
+        const fieldTypes = renderFields({
+            models,
+            model: fileModel,
+            fields,
+            type: "manage",
+            fieldRegistry: this.fieldRegistry
+        });
+        const inputCreateFields = renderInputFields({
+            models,
+            model: fileModel,
+            fields,
+            fieldRegistry: this.fieldRegistry
+        });
+        const inputUpdateFields = renderInputFields({
+            models,
+            model: fileModel,
+            fields: createUpdateFields(fields),
+            fieldRegistry: this.fieldRegistry
+        });
+        const listFilterFieldsRender = renderListFilterFields({
+            model: fileModel,
+            fields: fileModel.fields,
+            type: "manage",
+            fieldRegistry: this.fieldRegistry,
+            excludeFields: [
+                "entryId",
+                "status"
+            ]
+        });
+        builder.addTypeDefs(`
+            type FmFile_Location {
+                folderId: ID!
+            }
+
+            input FmFile_LocationInput {
+                folderId: ID!
+            }
+
+            input FmFile_LocationWhereInput {
+                folderId: ID
+                folderId_in: [ID!]
+                folderId_not: ID
+                folderId_not_in: [ID!]
+            }
+
+            ${fieldTypes.map((f)=>f.typeDefs).join("\n")}
+
+            type FmFile {
+                id: ID!
+                createdOn: DateTime!
+                modifiedOn: DateTime
+                savedOn: DateTime!
+                createdBy: FmCreatedBy!
+                modifiedBy: FmCreatedBy
+                savedBy: FmCreatedBy!
+                location: FmFile_Location!
+                src: String
+                ${fieldTypes.map((f)=>f.fields).join("\n")}
+            }
+
+            ${inputCreateFields.map((f)=>f.typeDefs).join("\n")}
+
+            input FmCreatedByInput {
+                id: ID!
+                displayName: String!
+                type: String!
+            }
+
+            input FmFileCreateInput {
+                id: ID!
+                createdOn: DateTime
+                modifiedOn: DateTime
+                savedOn: DateTime
+                createdBy: FmCreatedByInput
+                modifiedBy: FmCreatedByInput
+                savedBy: FmCreatedByInput
+                location: FmFile_LocationInput
+                ${inputCreateFields.map((f)=>f.fields).join("\n")}
+            }
+
+            input FmFileUpdateInput {
+                createdOn: DateTime
+                modifiedOn: DateTime
+                savedOn: DateTime
+                createdBy: FmCreatedByInput
+                modifiedBy: FmCreatedByInput
+                savedBy: FmCreatedByInput
+                location: FmFile_LocationInput
+                ${inputUpdateFields.map((f)=>f.fields).join("\n")}
+            }
+
+            type FmFileResponse {
+                data: FmFile
+                error: FmError
+            }
+
+            input FmFileListWhereInput {
+                ${listFilterFieldsRender.allFiltersAsString()}
+                location: FmFile_LocationWhereInput
+                AND: [FmFileListWhereInput!]
+                OR: [FmFileListWhereInput!]
+            }
+
+            type FmFileListResponse {
+                data: [FmFile!]
+                error: FmError
+                meta: FmListMeta
+            }
+
+            enum FmFileListSorter {
+                savedOn_ASC
+                savedOn_DESC
+                createdOn_ASC
+                createdOn_DESC
+                name_ASC
+                name_DESC
+                key_ASC
+                key_DESC
+                type_ASC
+                type_DESC
+                size_ASC
+                size_DESC
+            }
+
+            input FmTagsListWhereInput {
+                createdBy: String
+                tags_startsWith: String
+                tags_not_startsWith: String
+            }
+
+            type FmTag {
+                tag: String!
+                count: Number!
+            }
+
+            type FmTagsListResponse {
+                data: [FmTag!]
+                error: FmError
+            }
+
+            type FmCreateFilesResponse {
+                data: [FmFile!]
+                error: FmError
+            }
+
+            type FmFileModelResponse {
+                data: JSON
+                error: FmError
+            }
+
+            extend type FmQuery {
+                getFileModel: FmFileModelResponse!
+                getFile(id: ID!): FmFileResponse!
+                getFileByUrl(url: String!): FmFileResponse
+                listFiles(
+                    search: String
+                    where: FmFileListWhereInput
+                    limit: Int
+                    after: String
+                    sort: [FmFileListSorter!]
+                ): FmFileListResponse!
+                listTags(where: FmTagsListWhereInput): FmTagsListResponse!
+            }
+
+            extend type FmMutation {
+                createFile(data: FmFileCreateInput!): FmFileResponse!
+                createFiles(data: [FmFileCreateInput!]!): FmCreateFilesResponse!
+                updateFile(id: ID!, data: FmFileUpdateInput!): FmFileResponse!
+                deleteFile(id: ID!): FmBooleanResponse!
+            }
+        `);
+    }
+    addSettingsResolvers(builder) {
+        builder.addResolver({
+            path: "FmQuery.getSettings",
+            dependencies: [
+                GetSettingsUseCase
+            ],
+            resolver: (getSettings)=>async ()=>{
+                    const result = await getSettings.execute();
+                    if (result.isFail()) return new ErrorResponse(result.error);
+                    return new Response(result.value);
+                }
+        });
+        builder.addResolver({
+            path: "FmMutation.updateSettings",
+            dependencies: [
+                UpdateSettingsUseCase
+            ],
+            resolver: (updateSettings)=>async ({ args })=>{
+                    const result = await updateSettings.execute(args.data);
+                    if (result.isFail()) return new ErrorResponse(result.error);
+                    return new Response(result.value);
+                }
+        });
+    }
+    addFileQueryResolvers(builder) {
+        builder.addResolver({
+            path: "FmFile.src",
+            dependencies: [
+                FileUrlGenerator
+            ],
+            resolver: (urlGenerator)=>({ parent })=>urlGenerator.generateUrl(parent)
+        });
+        builder.addResolver({
+            path: "FmQuery.getFileModel",
+            dependencies: [
+                FileModelProvider
+            ],
+            resolver: (fileModelProvider)=>async ()=>new Response(await fileModelProvider.get())
+        });
+        builder.addResolver({
+            path: "FmQuery.getFile",
+            dependencies: [
+                GetFileUseCase
+            ],
+            resolver: (getFile)=>async ({ args })=>{
+                    const result = await getFile.execute(args.id);
+                    if (result.isFail()) return new ErrorResponse(result.error);
+                    return new Response(result.value);
+                }
+        });
+        builder.addResolver({
+            path: "FmQuery.listFiles",
+            dependencies: [
+                ListFilesUseCase
+            ],
+            resolver: (listFiles)=>async ({ args })=>{
+                    const result = await listFiles.execute(args);
+                    if (result.isFail()) return new ErrorResponse(result.error);
+                    return new ListResponse(result.value.items, result.value.meta);
+                }
+        });
+        builder.addResolver({
+            path: "FmQuery.listTags",
+            dependencies: [
+                ListTagsUseCase
+            ],
+            resolver: (listTags)=>async ({ args })=>{
+                    const result = await listTags.execute(args || {});
+                    if (result.isFail()) return new ErrorResponse(result.error);
+                    return new Response(result.value);
+                }
+        });
+        builder.addResolver({
+            path: "FmQuery.getFileByUrl",
+            dependencies: [
+                GetFileByUrlUseCase
+            ],
+            resolver: (getFileByUrl)=>async ({ args })=>{
+                    const result = await getFileByUrl.execute(args.url);
+                    if (result.isFail()) return new ErrorResponse(result.error);
+                    if (!result.value) return new NotFoundResponse("File not found!");
+                    return new Response(result.value);
+                }
+        });
+    }
+    addFileMutationResolvers(builder) {
+        builder.addResolver({
+            path: "FmMutation.createFile",
+            dependencies: [
+                CreateFileUseCase
+            ],
+            resolver: (createFile)=>async ({ args })=>{
+                    const result = await createFile.execute(args.data);
+                    if (result.isFail()) return new ErrorResponse(result.error);
+                    return new Response(result.value);
+                }
+        });
+        builder.addResolver({
+            path: "FmMutation.createFiles",
+            dependencies: [
+                CreateFilesInBatchUseCase
+            ],
+            resolver: (createFilesInBatch)=>async ({ args })=>{
+                    const result = await createFilesInBatch.execute({
+                        files: args.data,
+                        meta: args.meta
+                    });
+                    if (result.isFail()) return new ErrorResponse(result.error);
+                    return new Response(result.value);
+                }
+        });
+        builder.addResolver({
+            path: "FmMutation.updateFile",
+            dependencies: [
+                UpdateFileUseCase
+            ],
+            resolver: (updateFile)=>async ({ args })=>{
+                    const result = await updateFile.execute({
+                        id: args.id,
+                        ...args.data
+                    });
+                    if (result.isFail()) return new ErrorResponse(result.error);
+                    return new Response(result.value);
+                }
+        });
+        builder.addResolver({
+            path: "FmMutation.deleteFile",
+            dependencies: [
+                DeleteFileUseCase
+            ],
+            resolver: (deleteFile)=>async ({ args })=>{
+                    const result = await deleteFile.execute(args.id);
+                    if (result.isFail()) return new ErrorResponse(result.error);
+                    return new Response(true);
+                }
+        });
+    }
+    async loadModels() {
+        const modelsResult = await this.identityContext.withoutAuthorization(()=>this.listModelsUseCase.execute());
+        return modelsResult.value;
+    }
+}
+const FmGraphQLSchema = GraphQLSchemaFactory.createImplementation({
+    implementation: FmGraphQLSchema_,
+    dependencies: [
+        IdentityContext,
+        ListModelsUseCase,
+        CmsModelFieldToGraphQLRegistry,
+        FileModelProvider
+    ]
+});
+export { FmGraphQLSchema };
+
+//# sourceMappingURL=FmGraphQLSchema.js.map