@medusajs/file 0.0.1 → 0.0.2-next-20240430121402

package/dist/index.d.ts

@@ -1,4 +1,7 @@
-import { moduleDefinition, revertMigration, runMigrations } from "./module-definition";
-export default moduleDefinition;
-export { revertMigration, runMigrations };
+import { moduleDefinition } from "./module-definition";
+export * from "./types";
 export * from "./services";
+export declare const initialize: (options?: import("@medusajs/modules-sdk").ModuleServiceInitializeOptions | import("@medusajs/modules-sdk").ModuleServiceInitializeCustomDataLayerOptions | import("@medusajs/modules-sdk").InternalModuleDeclaration | import("@medusajs/modules-sdk").ExternalModuleDeclaration | undefined, injectedDependencies?: any) => Promise<unknown>;
+export declare const runMigrations: ((options: import("@medusajs/modules-sdk").LoaderOptions<any>, moduleDeclaration?: import("@medusajs/modules-sdk").InternalModuleDeclaration | undefined) => Promise<void>) | undefined;
+export declare const revertMigration: ((options: import("@medusajs/modules-sdk").LoaderOptions<any>, moduleDeclaration?: import("@medusajs/modules-sdk").InternalModuleDeclaration | undefined) => Promise<void>) | undefined;
+export default moduleDefinition;

package/dist/index.js

@@ -14,9 +14,15 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.runMigrations = exports.revertMigration = void 0;
+exports.revertMigration = exports.runMigrations = exports.initialize = void 0;
 const module_definition_1 = require("./module-definition");
-Object.defineProperty(exports, "revertMigration", { enumerable: true, get: function () { return module_definition_1.revertMigration; } });
-Object.defineProperty(exports, "runMigrations", { enumerable: true, get: function () { return module_definition_1.runMigrations; } });
-exports.default = module_definition_1.moduleDefinition;
+const modules_sdk_1 = require("@medusajs/modules-sdk");
+__exportStar(require("./types"), exports);
 __exportStar(require("./services"), exports);
+exports.initialize = (0, modules_sdk_1.initializeFactory)({
+    moduleName: modules_sdk_1.Modules.FILE,
+    moduleDefinition: module_definition_1.moduleDefinition,
+});
+exports.runMigrations = module_definition_1.moduleDefinition.runMigrations;
+exports.revertMigration = module_definition_1.moduleDefinition.revertMigration;
+exports.default = module_definition_1.moduleDefinition;

package/dist/loaders/providers.d.ts

@@ -0,0 +1,5 @@
+import { LoaderOptions, ModuleProvider, ModulesSdkTypes } from "@medusajs/types";
+declare const _default: ({ container, options, }: LoaderOptions<(ModulesSdkTypes.ModuleServiceInitializeOptions | ModulesSdkTypes.ModuleServiceInitializeCustomDataLayerOptions) & {
+    providers: ModuleProvider[];
+}>) => Promise<void>;
+export default _default;

package/dist/loaders/providers.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const modules_sdk_1 = require("@medusajs/modules-sdk");
+const _services_1 = require("../services");
+const _types_1 = require("../types");
+const awilix_1 = require("awilix");
+const registrationFn = async (klass, container, pluginOptions) => {
+    Object.entries(pluginOptions.config || []).map(([name, config]) => {
+        const key = _services_1.FileProviderService.getRegistrationIdentifier(klass, name);
+        container.register({
+            [_types_1.FileProviderRegistrationPrefix + key]: (0, awilix_1.asFunction)((cradle) => new klass(cradle, config), {
+                lifetime: klass.LIFE_TIME || awilix_1.Lifetime.SINGLETON,
+            }),
+        });
+        container.registerAdd(_types_1.FileProviderIdentifierRegistrationName, (0, awilix_1.asValue)(key));
+    });
+};
+exports.default = async ({ container, options, }) => {
+    await (0, modules_sdk_1.moduleProviderLoader)({
+        container,
+        providers: options?.providers || [],
+        registerServiceFn: registrationFn,
+    });
+};

package/dist/module-definition.js

@@ -1,7 +1,36 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.moduleDefinition = exports.revertMigration = exports.runMigrations = void 0;
 const _services_1 = require("./services");
+const providers_1 = __importDefault(require("./loaders/providers"));
+const ModuleServices = __importStar(require("./services"));
+const utils_1 = require("@medusajs/utils");
 const runMigrations = () => {
     return Promise.resolve();
 };
@@ -10,8 +39,13 @@ const revertMigration = () => {
     return Promise.resolve();
 };
 exports.revertMigration = revertMigration;
+const containerLoader = utils_1.ModulesSdkUtils.moduleContainerLoaderFactory({
+    moduleModels: {},
+    moduleRepositories: {},
+    moduleServices: ModuleServices,
+});
+const loaders = [containerLoader, providers_1.default];
 const service = _services_1.FileModuleService;
-const loaders = [];
 exports.moduleDefinition = {
     service,
     loaders,

package/dist/services/file-module-service.d.ts

@@ -1,10 +1,18 @@
-import { Context, CreateFileDTO, FileDTO, ModuleJoinerConfig } from "@medusajs/types";
-export default class FileModuleService {
-    constructor();
+import { Context, CreateFileDTO, FileDTO, ModuleJoinerConfig, FileTypes, FilterableFileProps, FindConfig } from "@medusajs/types";
+import FileProviderService from "./file-provider-service";
+type InjectedDependencies = {
+    fileProviderService: FileProviderService;
+};
+export default class FileModuleService implements FileTypes.IFileModuleService {
+    protected readonly fileProviderService_: FileProviderService;
+    constructor({ fileProviderService }: InjectedDependencies);
     __joinerConfig(): ModuleJoinerConfig;
     create(data: CreateFileDTO[], sharedContext?: Context): Promise<FileDTO[]>;
     create(data: CreateFileDTO, sharedContext?: Context): Promise<FileDTO>;
     delete(ids: string[], sharedContext?: Context): Promise<void>;
     delete(id: string, sharedContext?: Context): Promise<void>;
     retrieve(id: string): Promise<FileDTO>;
+    list(filters?: FilterableFileProps, config?: FindConfig<FileDTO>, sharedContext?: Context): Promise<FileDTO[]>;
+    listAndCount(filters?: FilterableFileProps, config?: FindConfig<FileDTO>, sharedContext?: Context): Promise<[FileDTO[], number]>;
 }
+export {};

package/dist/services/file-module-service.js

@@ -1,25 +1,76 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const joiner_config_1 = require("../joiner-config");
+const medusa_core_utils_1 = require("medusa-core-utils");
 class FileModuleService {
-    constructor() {
-        // @ts-ignore
-        // eslint-disable-next-line prefer-rest-params
-        super(...arguments);
+    constructor({ fileProviderService }) {
+        this.fileProviderService_ = fileProviderService;
     }
     __joinerConfig() {
         return joiner_config_1.joinerConfig;
     }
     async create(data) {
         const input = Array.isArray(data) ? data : [data];
-        const files = [];
-        return Array.isArray(data) ? files : files[0];
+        // TODO: Validate file mime type, have config for allowed types
+        const files = await Promise.all(input.map((file) => this.fileProviderService_.upload(file)));
+        const result = files.map((file) => ({
+            id: file.key,
+            url: file.url,
+        }));
+        return Array.isArray(data) ? result : result[0];
     }
     async delete(ids) {
+        const input = Array.isArray(ids) ? ids : [ids];
+        await Promise.all(input.map((id) => this.fileProviderService_.delete({ fileKey: id })));
         return;
     }
     async retrieve(id) {
-        return {};
+        const res = await this.fileProviderService_.getPresignedDownloadUrl({
+            fileKey: id,
+        });
+        return {
+            id,
+            url: res,
+        };
+    }
+    async list(filters, config, sharedContext) {
+        const id = Array.isArray(filters?.id) ? filters?.id?.[0] : filters?.id;
+        if (!id) {
+            throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.INVALID_DATA, "Listing of files is only supported when filtering by ID.");
+        }
+        const res = await this.fileProviderService_.getPresignedDownloadUrl({
+            fileKey: id,
+        });
+        if (!res) {
+            return [];
+        }
+        return [
+            {
+                id,
+                url: res,
+            },
+        ];
+    }
+    async listAndCount(filters, config, sharedContext) {
+        const id = Array.isArray(filters?.id) ? filters?.id?.[0] : filters?.id;
+        if (!id) {
+            throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.INVALID_DATA, "Listing and counting of files is only supported when filtering by ID.");
+        }
+        const res = await this.fileProviderService_.getPresignedDownloadUrl({
+            fileKey: id,
+        });
+        if (!res) {
+            return [[], 0];
+        }
+        return [
+            [
+                {
+                    id,
+                    url: res,
+                },
+            ],
+            1,
+        ];
     }
 }
 exports.default = FileModuleService;

package/dist/services/file-provider-service.d.ts

@@ -0,0 +1,14 @@
+import { Constructor, FileTypes } from "@medusajs/types";
+import { FileProviderRegistrationPrefix } from "../types";
+type InjectedDependencies = {
+    [key: `${typeof FileProviderRegistrationPrefix}${string}`]: FileTypes.IFileProvider;
+};
+export default class FileProviderService {
+    protected readonly fileProvider_: FileTypes.IFileProvider;
+    constructor(container: InjectedDependencies);
+    static getRegistrationIdentifier(providerClass: Constructor<FileTypes.IFileProvider>, optionName?: string): string;
+    upload(file: FileTypes.ProviderUploadFileDTO): Promise<FileTypes.ProviderFileResultDTO>;
+    delete(fileData: FileTypes.ProviderDeleteFileDTO): Promise<void>;
+    getPresignedDownloadUrl(fileData: FileTypes.ProviderGetFileDTO): Promise<string>;
+}
+export {};

package/dist/services/file-provider-service.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const medusa_core_utils_1 = require("medusa-core-utils");
+const _types_1 = require("../types");
+class FileProviderService {
+    constructor(container) {
+        const fileProviderKeys = Object.keys(container).filter((k) => k.startsWith(_types_1.FileProviderRegistrationPrefix));
+        if (fileProviderKeys.length !== 1) {
+            throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.INVALID_DATA, `File module should be initialized with exactly one provider`);
+        }
+        this.fileProvider_ = container[fileProviderKeys[0]];
+    }
+    static getRegistrationIdentifier(providerClass, optionName) {
+        return `${providerClass.identifier}_${optionName}`;
+    }
+    upload(file) {
+        return this.fileProvider_.upload(file);
+    }
+    delete(fileData) {
+        return this.fileProvider_.delete(fileData);
+    }
+    getPresignedDownloadUrl(fileData) {
+        return this.fileProvider_.getPresignedDownloadUrl(fileData);
+    }
+}
+exports.default = FileProviderService;

package/dist/services/index.d.ts

@@ -1 +1,2 @@
 export { default as FileModuleService } from "./file-module-service";
+export { default as FileProviderService } from "./file-provider-service";

package/dist/services/index.js

@@ -3,6 +3,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FileModuleService = void 0;
+exports.FileProviderService = exports.FileModuleService = void 0;
 var file_module_service_1 = require("./file-module-service");
 Object.defineProperty(exports, "FileModuleService", { enumerable: true, get: function () { return __importDefault(file_module_service_1).default; } });
+var file_provider_service_1 = require("./file-provider-service");
+Object.defineProperty(exports, "FileProviderService", { enumerable: true, get: function () { return __importDefault(file_provider_service_1).default; } });

package/dist/types/index.d.ts

@@ -0,0 +1,20 @@
+import { ModuleProviderExports, ModuleServiceInitializeOptions } from "@medusajs/types";
+export declare const FileProviderIdentifierRegistrationName = "file_providers_identifier";
+export declare const FileProviderRegistrationPrefix = "fs_";
+export type FileModuleOptions = Partial<ModuleServiceInitializeOptions> & {
+    /**
+     * Providers to be registered
+     */
+    provider?: {
+        /**
+         * The module provider to be registered
+         */
+        resolve: string | ModuleProviderExports;
+        options: {
+            /**
+             * key value pair of the provider name and the configuration to be passed to the provider constructor
+             */
+            config: Record<string, unknown>;
+        };
+    };
+};

package/dist/types/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileProviderRegistrationPrefix = exports.FileProviderIdentifierRegistrationName = void 0;
+exports.FileProviderIdentifierRegistrationName = "file_providers_identifier";
+exports.FileProviderRegistrationPrefix = "fs_";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@medusajs/file",
-  "version": "0.0.1",
+  "version": "0.0.2-next-20240430121402",
   "description": "Medusa File module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -38,7 +38,7 @@
     "cross-env": "^5.2.1",
     "faker": "^6.6.6",
     "jest": "^29.6.3",
-    "medusa-test-utils": "^1.1.43",
+    "medusa-test-utils": "1.1.44-next-20240430121402",
     "pg-god": "^1.0.12",
     "rimraf": "^3.0.2",
     "ts-jest": "^29.1.1",
@@ -47,9 +47,9 @@
     "typescript": "^5.1.6"
   },
   "dependencies": {
-    "@medusajs/modules-sdk": "^1.12.10",
-    "@medusajs/types": "^1.11.15",
-    "@medusajs/utils": "^1.11.8",
+    "@medusajs/modules-sdk": "1.12.11-next-20240430121402",
+    "@medusajs/types": "1.11.16-next-20240430121402",
+    "@medusajs/utils": "1.11.9-next-20240430121402",
     "@mikro-orm/core": "5.9.7",
     "@mikro-orm/migrations": "5.9.7",
     "@mikro-orm/postgresql": "5.9.7",