@8medusa/utils 2.7.0

package/dist/auth/abstract-auth-provider.js

@@ -0,0 +1,296 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractAuthModuleProvider = void 0;
+/**
+ * ### constructor
+ *
+ * The constructor allows you to access resources from the module's container using the first parameter,
+ * and the module's options using the second parameter.
+ *
+ * If you're creating a client or establishing a connection with a third-party service, do it in the constructor.
+ *
+ * #### Example
+ *
+ * ```ts
+ * import { AbstractAuthModuleProvider } from "@8medusa/framework/utils"
+ * import { Logger } from "@8medusa/framework/types"
+ *
+ * type InjectedDependencies = {
+ *   logger: Logger
+ * }
+ *
+ * type Options = {
+ *   apiKey: string
+ * }
+ *
+ * class MyAuthProviderService extends AbstractAuthModuleProvider {
+ *   static identifier = "my-auth"
+ *   protected logger_: Logger
+ *   protected options_: Options
+ *   // assuming you're initializing a client
+ *   protected client
+ *
+ *   constructor (
+ *     { logger }: InjectedDependencies,
+ *     options: Options
+ *   ) {
+ *     super(...arguments)
+ *
+ *     this.logger_ = logger
+ *     this.options_ = options
+ *
+ *     // assuming you're initializing a client
+ *     this.client = new Client(options)
+ *   }
+ *
+ *   // ...
+ * }
+ *
+ * export default MyAuthProviderService
+ * ```
+ */
+class AbstractAuthModuleProvider {
+    /**
+     * @deprecated Use `identifier` instead.
+     * @ignore
+     */
+    get provider() {
+        return this.constructor.identifier;
+    }
+    /**
+     * @ignore
+     */
+    get identifier() {
+        return this.constructor.identifier;
+    }
+    /**
+     * @ignore
+     */
+    get displayName() {
+        return this.constructor.DISPLAY_NAME;
+    }
+    /**
+     * This method validates the options of the provider set in `medusa-config.ts`.
+     * Implementing this method is optional. It's useful if your provider requires custom validation.
+     *
+     * If the options aren't valid, throw an error.
+     *
+     * @param options - The provider's options.
+     *
+     * @example
+     * class MyAuthProviderService extends AbstractAuthModuleProvider {
+     *   static validateOptions(options: Record<any, any>) {
+     *     if (!options.apiKey) {
+     *       throw new MedusaError(
+     *         MedusaError.Types.INVALID_DATA,
+     *         "API key is required in the provider's options."
+     *       )
+     *     }
+     *   }
+     *   // ...
+     * }
+     */
+    static validateOptions(options) { }
+    /**
+     * This method receives credentails to create a new auth identity. It performs any validation necessary
+     * before creating the auth identity.
+     *
+     * For example, in the `emailpass` provider, this method ensures that the provided email doesn't exist
+     * before creating the auth identity.
+     *
+     * This method is only used in a basic authentication flow, such as when using an email and password
+     * to register and authenticate a user.
+     *
+     * Related Read: [Learn about the different authentication flows in Medusa](https://docs.medusajs.com/resources/commerce-modules/auth/authentication-route).
+     *
+     * @param {AuthenticationInput} data - The details of the authentication request.
+     * @param {AuthIdentityProviderService} authIdentityProviderService - The service used to retrieve or
+     * create an auth identity. It has two methods: `create` to create an auth identity,
+     * and `retrieve` to retrieve an auth identity. When you authenticate the user, you can create an auth identity
+     * using this service.
+     * @returns The created authentication identity if no errors occur.
+     *
+     * @example
+     * import {
+     *   AuthIdentityProviderService,
+     *   AuthenticationInput,
+     *   AuthenticationResponse
+     * } from "@8medusa/framework/types"
+     * import { MedusaError } from "@8medusa/framework/utils"
+     * // ...
+     *
+     * class MyAuthProviderService extends AbstractAuthModuleProvider {
+     *   // ...
+     *   async register(
+     *     data: AuthenticationInput,
+     *     authIdentityProviderService: AuthIdentityProviderService
+     *   ): Promise<AuthenticationResponse> {
+     *     try {
+     *       await authIdentityService.retrieve({
+     *         entity_id: data.body.email, // email or some ID
+     *       })
+     *
+     *       return {
+     *         success: false,
+     *         error: "Identity with email already exists",
+     *       }
+     *     } catch (error) {
+     *       if (error.type === MedusaError.Types.NOT_FOUND) {
+     *         const createdAuthIdentity = await authIdentityProviderService.create({
+     *           entity_id: data.body.email, // email or some ID
+     *           provider: this.provider,
+     *           provider_metadata: {
+     *             // can include password or any other relevant information
+     *           }
+     *         })
+     *
+     *         return {
+     *           success: true,
+     *           authIdentity: createdAuthIdentity,
+     *         }
+     *       }
+     *
+     *       return { success: false, error: error.message }
+     *     }
+     *   }
+     * }
+     */
+    register(data, authIdentityProviderService) {
+        throw new Error(`Method 'register' not implemented for provider ${this.provider}`);
+    }
+    /**
+     * This method is used to update an auth identity's details.
+     *
+     * For example, the `emailpass` provider's implementation of this method updates a user's password.
+     *
+     * @param data - Data relevant to identify the auth identity and what to update in it. For example,
+     * the `emailpass` provider expects in this object an `email` and `password` properties.
+     * @param authIdentityProviderService - The service used to retrieve or
+     * create an auth identity. It has two methods: `create` to create an auth identity,
+     * and `retrieve` to retrieve an auth identity. When you authenticate the user, you can create an auth identity
+     * using this service.
+     * @returns The updated authentication identity if no errors occur.
+     *
+     * @example
+     * import {
+     *   AuthIdentityProviderService,
+     *   AuthenticationInput,
+     *   AuthenticationResponse
+     * } from "@8medusa/framework/types"
+     * import { MedusaError } from "@8medusa/framework/utils"
+     * // ...
+     *
+     * class MyAuthProviderService extends AbstractAuthModuleProvider {
+     *   // ...
+     *   async update(
+     *     data: Record<string, unknown>,
+     *     authIdentityProviderService: AuthIdentityProviderService
+     *   ): Promise<AuthenticationResponse> {
+     *     try {
+     *       const authIdentity = await authIdentityService.update(
+     *         data.email, // email or some ID used to identify the auth identity
+     *         {
+     *           user: data.user // example
+     *         }
+     *       )
+     *
+     *       return { success: true, authIdentity }
+     *     } catch (error) {
+     *       return { success: false, error: error.message }
+     *     }
+     *   }
+     * }
+     */
+    update(data, authIdentityProviderService) {
+        throw new Error(`Method 'update' not implemented for provider ${this.provider}`);
+    }
+    /**
+     * This method validates the callback of an authentication request.
+     *
+     * In an authentication flow that requires performing an action with a third-party service, such as login
+     * with a social account, the {@link authenticate} method is called first.
+     *
+     * Then, the third-party service redirects to a frontend URL passing it a `code` query parameter.
+     * The frontend should then send a request to the Medusa application's validate callback API route, passing it the code.
+     * That route uses this method to verify the callback's code.
+     *
+     * If the callback is verified successfully, the provider creates an auth identity for the user, or updates the auth identity's user information.
+     *
+     * In the auth identity, use the following properties to store additional data:
+     *
+     * - `provider_metadata`: Store metadata useful for the provider, such as a password hash.
+     * - `user_metadata`: Store metadata of the user's details. For example, if the third-party service returns the user's information such as email
+     * or name, you store this data in this property.
+     *
+     * Related Guide: [Learn about the different authentication flows in Medusa](https://docs.medusajs.com/resources/commerce-modules/auth/authentication-route).
+     *
+     * @param {AuthenticationInput} data - The details of the authentication request.
+     * @param {AuthIdentityProviderService} authIdentityProviderService - The service used to retrieve or
+     * create an auth identity. It has two methods: `create` to create an auth identity,
+     * and `retrieve` to retrieve an auth identity. When you authenticate the user, you can create an auth identity
+     * using this service.
+     * @returns {Promise<AuthenticationResponse>} The authentication response.
+     *
+     * @example
+     * import {
+     *   AuthIdentityProviderService,
+     *   AuthenticationInput,
+     *   AuthenticationResponse
+     * } from "@8medusa/framework/types"
+     * // ...
+     *
+     * class MyAuthProviderService extends AbstractAuthModuleProvider {
+     *   // ...
+     *   async validateCallback(
+     *     data: AuthenticationInput,
+     *     authIdentityProviderService: AuthIdentityProviderService
+     *   ): Promise<AuthenticationResponse> {
+     *     const isAuthenticated = false
+     *     // TODO perform custom logic to authenticate the user
+     *     // ...
+     *
+     *     if (!isAuthenticated) {
+     *       // if the authentication didn't succeed, return
+     *       // an object of the following format
+     *       return {
+     *         success: false,
+     *         error: "Something went wrong"
+     *       }
+     *     }
+     *
+     *     // authentication is successful, create an auth identity
+     *     // if doesn't exist
+     *     let authIdentity
+     *
+     *     try {
+     *       authIdentity = await authIdentityProviderService.retrieve({
+     *         entity_id: data.body.email, // email or some ID
+     *         provider: this.provider
+     *       })
+     *     } catch (e) {
+     *       // The auth identity doesn't exist so create it
+     *       authIdentity = await authIdentityProviderService.create({
+     *         entity_id: data.body.email, // email or some ID
+     *         provider: this.provider,
+     *         provider_metadata: {
+     *           // can include password or any other relevant information
+     *         },
+     *         user_metadata: {
+     *           // can include data retrieved from the third-party service
+     *         }
+     *       })
+     *     }
+     *
+     *     return {
+     *       success: true,
+     *       authIdentity
+     *     }
+     *   }
+     * }
+     */
+    validateCallback(data, authIdentityProviderService) {
+        throw new Error(`Callback authentication not implemented for provider ${this.provider}`);
+    }
+}
+exports.AbstractAuthModuleProvider = AbstractAuthModuleProvider;
+//# sourceMappingURL=abstract-auth-provider.js.map

package/dist/auth/abstract-auth-provider.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"abstract-auth-provider.js","sourceRoot":"","sources":["../../src/auth/abstract-auth-provider.ts"],"names":[],"mappings":";;;AAOA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AACH,MAAsB,0BAA0B;IA8B9C;;;OAGG;IACH,IAAW,QAAQ;QACjB,OAAQ,IAAI,CAAC,WAAiD,CAAC,UAAU,CAAA;IAC3E,CAAC;IAED;;OAEG;IACH,IAAW,UAAU;QACnB,OAAQ,IAAI,CAAC,WAAiD,CAAC,UAAU,CAAA;IAC3E,CAAC;IAED;;OAEG;IACH,IAAW,WAAW;QACpB,OAAQ,IAAI,CAAC,WAAiD,CAAC,YAAY,CAAA;IAC7E,CAAC;IAED;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,MAAM,CAAC,eAAe,CAAC,OAAyB,IAAiB,CAAC;IAuGlE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+DG;IACH,QAAQ,CACN,IAAyB,EACzB,2BAAwD;QAExD,MAAM,IAAI,KAAK,CACb,kDAAkD,IAAI,CAAC,QAAQ,EAAE,CAClE,CAAA;IACH,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA0CG;IACH,MAAM,CACJ,IAA6B,EAC7B,2BAAwD;QAExD,MAAM,IAAI,KAAK,CACb,gDAAgD,IAAI,CAAC,QAAQ,EAAE,CAChE,CAAA;IACH,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAmFG;IACH,gBAAgB,CACd,IAAyB,EACzB,2BAAwD;QAExD,MAAM,IAAI,KAAK,CACb,wDAAwD,IAAI,CAAC,QAAQ,EAAE,CACxE,CAAA;IACH,CAAC;CACF;AAzYD,gEAyYC"}

package/dist/auth/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./abstract-auth-provider";
+export * from "./token";
+//# sourceMappingURL=index.d.ts.map

package/dist/auth/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/auth/index.ts"],"names":[],"mappings":"AAAA,cAAc,0BAA0B,CAAA;AACxC,cAAc,SAAS,CAAA"}

package/dist/auth/index.js

@@ -0,0 +1,19 @@
+"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 __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 });
+__exportStar(require("./abstract-auth-provider"), exports);
+__exportStar(require("./token"), exports);
+//# sourceMappingURL=index.js.map

package/dist/auth/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/auth/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,2DAAwC;AACxC,0CAAuB"}

package/dist/auth/token.d.ts

@@ -0,0 +1,5 @@
+export declare const generateJwtToken: (tokenPayload: Record<string, unknown>, jwtConfig: {
+    secret: string | undefined;
+    expiresIn: string | undefined;
+}) => string;
+//# sourceMappingURL=token.d.ts.map

package/dist/auth/token.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"token.d.ts","sourceRoot":"","sources":["../../src/auth/token.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,gBAAgB,iBACb,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,aAC1B;IACT,MAAM,EAAE,MAAM,GAAG,SAAS,CAAA;IAC1B,SAAS,EAAE,MAAM,GAAG,SAAS,CAAA;CAC9B,WAYF,CAAA"}

package/dist/auth/token.js

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateJwtToken = void 0;
+const jsonwebtoken_1 = __importDefault(require("jsonwebtoken"));
+const common_1 = require("../common");
+const generateJwtToken = (tokenPayload, jwtConfig) => {
+    if (!jwtConfig.secret || !jwtConfig.expiresIn) {
+        throw new common_1.MedusaError(common_1.MedusaError.Types.INVALID_ARGUMENT, "JWT secret and expiresIn must be provided when generating a token");
+    }
+    return jsonwebtoken_1.default.sign(tokenPayload, jwtConfig.secret, {
+        expiresIn: jwtConfig.expiresIn,
+    });
+};
+exports.generateJwtToken = generateJwtToken;
+//# sourceMappingURL=token.js.map

package/dist/auth/token.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"token.js","sourceRoot":"","sources":["../../src/auth/token.ts"],"names":[],"mappings":";;;;;;AAAA,gEAA8B;AAC9B,sCAAuC;AAEhC,MAAM,gBAAgB,GAAG,CAC9B,YAAqC,EACrC,SAGC,EACD,EAAE;IACF,IAAI,CAAC,SAAS,CAAC,MAAM,IAAI,CAAC,SAAS,CAAC,SAAS,EAAE,CAAC;QAC9C,MAAM,IAAI,oBAAW,CACnB,oBAAW,CAAC,KAAK,CAAC,gBAAgB,EAClC,mEAAmE,CACpE,CAAA;IACH,CAAC;IAED,OAAO,sBAAG,CAAC,IAAI,CAAC,YAAY,EAAE,SAAS,CAAC,MAAM,EAAE;QAC9C,SAAS,EAAE,SAAS,CAAC,SAAS;KAC/B,CAAC,CAAA;AACJ,CAAC,CAAA;AAjBY,QAAA,gBAAgB,oBAiB5B"}

package/dist/bundles.d.ts

@@ -0,0 +1,21 @@
+export * as ApiKeyUtils from "./api-key";
+export * as CoreFlowsUitls from "./core-flows";
+export * as DALUtils from "./dal";
+export * as DefaultsUtils from "./defaults";
+export * as DMLUtils from "./dml";
+export * as EventBusUtils from "./event-bus";
+export * as FeatureFlagUtils from "./feature-flags";
+export * as FulfillmentUtils from "./fulfillment";
+export * as GraphQLUtils from "./graphql";
+export * as InventoryUtils from "./inventory";
+export * as LinkUtils from "./link";
+export * as ModulesSdkUtils from "./modules-sdk";
+export * as OrchestrationUtils from "./orchestration";
+export * as OrderUtils from "./order";
+export * as PricingUtils from "./pricing";
+export * as ProductUtils from "./product";
+export * as PromotionUtils from "./promotion";
+export * as SearchUtils from "./search";
+export * as ShippingProfileUtils from "./shipping";
+export * as UserUtils from "./user";
+//# sourceMappingURL=bundles.d.ts.map

package/dist/bundles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bundles.d.ts","sourceRoot":"","sources":["../src/bundles.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,WAAW,MAAM,WAAW,CAAA;AACxC,OAAO,KAAK,cAAc,MAAM,cAAc,CAAA;AAC9C,OAAO,KAAK,QAAQ,MAAM,OAAO,CAAA;AACjC,OAAO,KAAK,aAAa,MAAM,YAAY,CAAA;AAC3C,OAAO,KAAK,QAAQ,MAAM,OAAO,CAAA;AACjC,OAAO,KAAK,aAAa,MAAM,aAAa,CAAA;AAC5C,OAAO,KAAK,gBAAgB,MAAM,iBAAiB,CAAA;AACnD,OAAO,KAAK,gBAAgB,MAAM,eAAe,CAAA;AACjD,OAAO,KAAK,YAAY,MAAM,WAAW,CAAA;AACzC,OAAO,KAAK,cAAc,MAAM,aAAa,CAAA;AAC7C,OAAO,KAAK,SAAS,MAAM,QAAQ,CAAA;AACnC,OAAO,KAAK,eAAe,MAAM,eAAe,CAAA;AAChD,OAAO,KAAK,kBAAkB,MAAM,iBAAiB,CAAA;AACrD,OAAO,KAAK,UAAU,MAAM,SAAS,CAAA;AACrC,OAAO,KAAK,YAAY,MAAM,WAAW,CAAA;AACzC,OAAO,KAAK,YAAY,MAAM,WAAW,CAAA;AACzC,OAAO,KAAK,cAAc,MAAM,aAAa,CAAA;AAC7C,OAAO,KAAK,WAAW,MAAM,UAAU,CAAA;AACvC,OAAO,KAAK,oBAAoB,MAAM,YAAY,CAAA;AAClD,OAAO,KAAK,SAAS,MAAM,QAAQ,CAAA"}

package/dist/bundles.js

@@ -0,0 +1,47 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserUtils = exports.ShippingProfileUtils = exports.SearchUtils = exports.PromotionUtils = exports.ProductUtils = exports.PricingUtils = exports.OrderUtils = exports.OrchestrationUtils = exports.ModulesSdkUtils = exports.LinkUtils = exports.InventoryUtils = exports.GraphQLUtils = exports.FulfillmentUtils = exports.FeatureFlagUtils = exports.EventBusUtils = exports.DMLUtils = exports.DefaultsUtils = exports.DALUtils = exports.CoreFlowsUitls = exports.ApiKeyUtils = void 0;
+exports.ApiKeyUtils = __importStar(require("./api-key"));
+exports.CoreFlowsUitls = __importStar(require("./core-flows"));
+exports.DALUtils = __importStar(require("./dal"));
+exports.DefaultsUtils = __importStar(require("./defaults"));
+exports.DMLUtils = __importStar(require("./dml"));
+exports.EventBusUtils = __importStar(require("./event-bus"));
+exports.FeatureFlagUtils = __importStar(require("./feature-flags"));
+exports.FulfillmentUtils = __importStar(require("./fulfillment"));
+exports.GraphQLUtils = __importStar(require("./graphql"));
+exports.InventoryUtils = __importStar(require("./inventory"));
+exports.LinkUtils = __importStar(require("./link"));
+exports.ModulesSdkUtils = __importStar(require("./modules-sdk"));
+exports.OrchestrationUtils = __importStar(require("./orchestration"));
+exports.OrderUtils = __importStar(require("./order"));
+exports.PricingUtils = __importStar(require("./pricing"));
+exports.ProductUtils = __importStar(require("./product"));
+exports.PromotionUtils = __importStar(require("./promotion"));
+exports.SearchUtils = __importStar(require("./search"));
+exports.ShippingProfileUtils = __importStar(require("./shipping"));
+exports.UserUtils = __importStar(require("./user"));
+//# sourceMappingURL=bundles.js.map

package/dist/bundles.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bundles.js","sourceRoot":"","sources":["../src/bundles.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,yDAAwC;AACxC,+DAA8C;AAC9C,kDAAiC;AACjC,4DAA2C;AAC3C,kDAAiC;AACjC,6DAA4C;AAC5C,oEAAmD;AACnD,kEAAiD;AACjD,0DAAyC;AACzC,8DAA6C;AAC7C,oDAAmC;AACnC,iEAAgD;AAChD,sEAAqD;AACrD,sDAAqC;AACrC,0DAAyC;AACzC,0DAAyC;AACzC,8DAA6C;AAC7C,wDAAuC;AACvC,mEAAkD;AAClD,oDAAmC"}

package/dist/common/alter-columns-helper.d.ts

@@ -0,0 +1,2 @@
+export declare function generatePostgresAlterColummnIfExistStatement(tableName: string, columns: string[], alterExpression: string): string;
+//# sourceMappingURL=alter-columns-helper.d.ts.map

package/dist/common/alter-columns-helper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"alter-columns-helper.d.ts","sourceRoot":"","sources":["../../src/common/alter-columns-helper.ts"],"names":[],"mappings":"AAAA,wBAAgB,4CAA4C,CAC1D,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,MAAM,EAAE,EACjB,eAAe,EAAE,MAAM,UA4BxB"}

package/dist/common/alter-columns-helper.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generatePostgresAlterColummnIfExistStatement = generatePostgresAlterColummnIfExistStatement;
+function generatePostgresAlterColummnIfExistStatement(tableName, columns, alterExpression) {
+    let script = `
+    DO $$
+    DECLARE
+        current_column text;
+    BEGIN`;
+    columns.forEach((column) => {
+        script += `
+        current_column := '${column}';
+        IF EXISTS (
+            SELECT 1 
+            FROM information_schema.columns 
+            WHERE table_name = '${tableName}' 
+            AND column_name = current_column
+        ) THEN
+            EXECUTE format('ALTER TABLE %I ALTER COLUMN %I ${alterExpression}', '${tableName}', current_column);
+        ELSE
+            RAISE NOTICE 'Column % does not exist or alteration condition not met.', current_column;
+        END IF;`;
+    });
+    script += `
+    END$$;
+    `;
+    return script;
+}
+//# sourceMappingURL=alter-columns-helper.js.map

package/dist/common/alter-columns-helper.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"alter-columns-helper.js","sourceRoot":"","sources":["../../src/common/alter-columns-helper.ts"],"names":[],"mappings":";;AAAA,oGA+BC;AA/BD,SAAgB,4CAA4C,CAC1D,SAAiB,EACjB,OAAiB,EACjB,eAAuB;IAEvB,IAAI,MAAM,GAAG;;;;UAIL,CAAA;IAER,OAAO,CAAC,OAAO,CAAC,CAAC,MAAM,EAAE,EAAE;QACzB,MAAM,IAAI;6BACe,MAAM;;;;kCAID,SAAS;;;6DAGkB,eAAe,OAAO,SAAS;;;gBAG5E,CAAA;IACd,CAAC,CAAC,CAAA;IAEF,MAAM,IAAI;;KAEP,CAAA;IAEH,OAAO,MAAM,CAAA;AACf,CAAC"}

package/dist/common/array-difference.d.ts

@@ -0,0 +1,4 @@
+type ArrayDifferenceElement = string | number;
+export declare function arrayDifference<TElement = ArrayDifferenceElement>(mainArray: TElement[], differingArray: TElement[]): TElement[];
+export {};
+//# sourceMappingURL=array-difference.d.ts.map

package/dist/common/array-difference.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"array-difference.d.ts","sourceRoot":"","sources":["../../src/common/array-difference.ts"],"names":[],"mappings":"AAAA,KAAK,sBAAsB,GAAG,MAAM,GAAG,MAAM,CAAA;AAE7C,wBAAgB,eAAe,CAAC,QAAQ,GAAG,sBAAsB,EAC/D,SAAS,EAAE,QAAQ,EAAE,EACrB,cAAc,EAAE,QAAQ,EAAE,GACzB,QAAQ,EAAE,CASZ"}

package/dist/common/array-difference.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.arrayDifference = arrayDifference;
+function arrayDifference(mainArray, differingArray) {
+    const mainArraySet = new Set(mainArray);
+    const differingArraySet = new Set(differingArray);
+    const difference = [...mainArraySet].filter((element) => !differingArraySet.has(element));
+    return difference;
+}
+//# sourceMappingURL=array-difference.js.map

package/dist/common/array-difference.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"array-difference.js","sourceRoot":"","sources":["../../src/common/array-difference.ts"],"names":[],"mappings":";;AAEA,0CAYC;AAZD,SAAgB,eAAe,CAC7B,SAAqB,EACrB,cAA0B;IAE1B,MAAM,YAAY,GAAG,IAAI,GAAG,CAAC,SAAS,CAAC,CAAA;IACvC,MAAM,iBAAiB,GAAG,IAAI,GAAG,CAAC,cAAc,CAAC,CAAA;IAEjD,MAAM,UAAU,GAAG,CAAC,GAAG,YAAY,CAAC,CAAC,MAAM,CACzC,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC,iBAAiB,CAAC,GAAG,CAAC,OAAO,CAAC,CAC7C,CAAA;IAED,OAAO,UAAU,CAAA;AACnB,CAAC"}

package/dist/common/array-intersection.d.ts

@@ -0,0 +1,4 @@
+type ArrayIntersectionElement = string | number;
+export declare function arrayIntersection<TElement = ArrayIntersectionElement>(firstArray: TElement[], secondArray: TElement[]): TElement[];
+export {};
+//# sourceMappingURL=array-intersection.d.ts.map

package/dist/common/array-intersection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"array-intersection.d.ts","sourceRoot":"","sources":["../../src/common/array-intersection.ts"],"names":[],"mappings":"AAAA,KAAK,wBAAwB,GAAG,MAAM,GAAG,MAAM,CAAA;AAE/C,wBAAgB,iBAAiB,CAAC,QAAQ,GAAG,wBAAwB,EACnE,UAAU,EAAE,QAAQ,EAAE,EACtB,WAAW,EAAE,QAAQ,EAAE,GACtB,QAAQ,EAAE,CAWZ"}

package/dist/common/array-intersection.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.arrayIntersection = arrayIntersection;
+function arrayIntersection(firstArray, secondArray) {
+    const firstArraySet = new Set(firstArray);
+    const res = new Set();
+    secondArray.forEach((element) => {
+        if (firstArraySet.has(element)) {
+            res.add(element);
+        }
+    });
+    return Array.from(res);
+}
+//# sourceMappingURL=array-intersection.js.map

package/dist/common/array-intersection.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"array-intersection.js","sourceRoot":"","sources":["../../src/common/array-intersection.ts"],"names":[],"mappings":";;AAEA,8CAcC;AAdD,SAAgB,iBAAiB,CAC/B,UAAsB,EACtB,WAAuB;IAEvB,MAAM,aAAa,GAAG,IAAI,GAAG,CAAC,UAAU,CAAC,CAAA;IACzC,MAAM,GAAG,GAAG,IAAI,GAAG,EAAY,CAAA;IAE/B,WAAW,CAAC,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE;QAC9B,IAAI,aAAa,CAAC,GAAG,CAAC,OAAO,CAAC,EAAE,CAAC;YAC/B,GAAG,CAAC,GAAG,CAAC,OAAO,CAAC,CAAA;QAClB,CAAC;IACH,CAAC,CAAC,CAAA;IAEF,OAAO,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,CAAA;AACxB,CAAC"}

package/dist/common/build-query.d.ts

@@ -0,0 +1,31 @@
+type Order = {
+    [key: string]: "ASC" | "DESC" | Order;
+};
+type Selects = {
+    [key: string]: boolean | Selects;
+};
+type Relations = {
+    [key: string]: boolean | Relations;
+};
+export declare function buildSelects(selectCollection: string[]): Selects;
+export declare function buildRelations(relationCollection: string[]): Relations;
+/**
+ * Convert an order of dot string into a nested object
+ * @example
+ * input: { id: "ASC", "items.title": "ASC", "items.variant.title": "ASC" }
+ * output: {
+ *   "id": "ASC",
+ *   "items": {
+ *     "id": "ASC",
+ *     "variant": {
+ *        "title": "ASC"
+ *     }
+ *   },
+ * }
+ * @param orderBy
+ */
+export declare function buildOrder(orderBy: {
+    [k: string]: "ASC" | "DESC";
+}): Order;
+export {};
+//# sourceMappingURL=build-query.d.ts.map

package/dist/common/build-query.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"build-query.d.ts","sourceRoot":"","sources":["../../src/common/build-query.ts"],"names":[],"mappings":"AAIA,KAAK,KAAK,GAAG;IACX,CAAC,GAAG,EAAE,MAAM,GAAG,KAAK,GAAG,MAAM,GAAG,KAAK,CAAA;CACtC,CAAA;AAED,KAAK,OAAO,GAAG;IACb,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,GAAG,OAAO,CAAA;CACjC,CAAA;AAED,KAAK,SAAS,GAAG;IACf,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,GAAG,SAAS,CAAA;CACnC,CAAA;AAED,wBAAgB,YAAY,CAAC,gBAAgB,EAAE,MAAM,EAAE,GAAG,OAAO,CAEhE;AAED,wBAAgB,cAAc,CAAC,kBAAkB,EAAE,MAAM,EAAE,GAAG,SAAS,CAEtE;AAMD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,UAAU,CAAC,OAAO,EAAE;IAAE,CAAC,CAAC,EAAE,MAAM,GAAG,KAAK,GAAG,MAAM,CAAA;CAAE,GAAG,KAAK,CAyB1E"}

package/dist/common/build-query.js

@@ -0,0 +1,50 @@
+"use strict";
+// Those utils are used in a typeorm context and we can't be sure that they can be used elsewhere
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildSelects = buildSelects;
+exports.buildRelations = buildRelations;
+exports.buildOrder = buildOrder;
+const object_from_string_path_1 = require("./object-from-string-path");
+function buildSelects(selectCollection) {
+    return buildRelationsOrSelect(selectCollection);
+}
+function buildRelations(relationCollection) {
+    return buildRelationsOrSelect(relationCollection);
+}
+function buildRelationsOrSelect(collection) {
+    return (0, object_from_string_path_1.objectFromStringPath)(collection);
+}
+/**
+ * Convert an order of dot string into a nested object
+ * @example
+ * input: { id: "ASC", "items.title": "ASC", "items.variant.title": "ASC" }
+ * output: {
+ *   "id": "ASC",
+ *   "items": {
+ *     "id": "ASC",
+ *     "variant": {
+ *        "title": "ASC"
+ *     }
+ *   },
+ * }
+ * @param orderBy
+ */
+function buildOrder(orderBy) {
+    const output = {};
+    const orderKeys = Object.keys(orderBy);
+    for (const order of orderKeys) {
+        if (order.indexOf(".") > -1) {
+            const nestedOrder = order.split(".");
+            let parent = output;
+            while (nestedOrder.length > 1) {
+                const nestedRelation = nestedOrder.shift();
+                parent = parent[nestedRelation] ??= {};
+            }
+            parent[nestedOrder[0]] = orderBy[order];
+            continue;
+        }
+        output[order] = orderBy[order];
+    }
+    return output;
+}
+//# sourceMappingURL=build-query.js.map

package/dist/common/build-query.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"build-query.js","sourceRoot":"","sources":["../../src/common/build-query.ts"],"names":[],"mappings":";AAAA,iGAAiG;;AAgBjG,oCAEC;AAED,wCAEC;AAqBD,gCAyBC;AAlED,uEAAgE;AAchE,SAAgB,YAAY,CAAC,gBAA0B;IACrD,OAAO,sBAAsB,CAAC,gBAAgB,CAAC,CAAA;AACjD,CAAC;AAED,SAAgB,cAAc,CAAC,kBAA4B;IACzD,OAAO,sBAAsB,CAAC,kBAAkB,CAAC,CAAA;AACnD,CAAC;AAED,SAAS,sBAAsB,CAAC,UAAoB;IAClD,OAAO,IAAA,8CAAoB,EAAC,UAAU,CAAC,CAAA;AACzC,CAAC;AAED;;;;;;;;;;;;;;GAcG;AACH,SAAgB,UAAU,CAAC,OAAwC;IACjE,MAAM,MAAM,GAAU,EAAE,CAAA;IAExB,MAAM,SAAS,GAAG,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAA;IAEtC,KAAK,MAAM,KAAK,IAAI,SAAS,EAAE,CAAC;QAC9B,IAAI,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC;YAC5B,MAAM,WAAW,GAAG,KAAK,CAAC,KAAK,CAAC,GAAG,CAAC,CAAA;YAEpC,IAAI,MAAM,GAAG,MAAM,CAAA;YAEnB,OAAO,WAAW,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;gBAC9B,MAAM,cAAc,GAAG,WAAW,CAAC,KAAK,EAAY,CAAA;gBACpD,MAAM,GAAI,MAAM,CAAC,cAAc,CAAW,KAAK,EAAE,CAAA;YACnD,CAAC;YAED,MAAM,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,KAAK,CAAC,CAAA;YAEvC,SAAQ;QACV,CAAC;QAED,MAAM,CAAC,KAAK,CAAC,GAAG,OAAO,CAAC,KAAK,CAAC,CAAA;IAChC,CAAC;IAED,OAAO,MAAM,CAAA;AACf,CAAC"}

package/dist/common/build-regexp-if-valid.d.ts

@@ -0,0 +1,2 @@
+export declare function buildRegexpIfValid(str: string): RegExp | undefined;
+//# sourceMappingURL=build-regexp-if-valid.d.ts.map

package/dist/common/build-regexp-if-valid.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"build-regexp-if-valid.d.ts","sourceRoot":"","sources":["../../src/common/build-regexp-if-valid.ts"],"names":[],"mappings":"AAAA,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CASlE"}