@infrab4a/connect 3.3.0-beta.1 → 3.3.0-beta.2

package/esm2020/infra/hasura-graphql/mixins/with-hasura-graphql.mixin.mjs

@@ -0,0 +1,92 @@
+import { mutation, query } from 'gql-query-builder';
+import fetch from 'node-fetch';
+import { isBoolean, isInteger, isNaN, isNil, isNumber, isString, isUUID, parseISO, } from '../../../utils';
+import { GraphQLFieldHelper } from './helpers';
+export const withHasuraGraphQL = (MixinBase) => {
+    return class HasuraGraphQLMixin extends MixinBase {
+        constructor(...params) {
+            const options = params[0];
+            super(...params);
+            this.tableName = options.tableName;
+            this.endpoint = options.endpoint;
+            this.authOptions = options.authOptions;
+            this.model = options.model;
+            this.fields = options.fields || this.model.identifiersFields;
+        }
+        get headers() {
+            return {
+                'Content-Type': 'application/json',
+                ...(isNil(this.authOptions.authToken) ? {} : { Authorization: this.authOptions.authToken }),
+                ...(isNil(this.authOptions.adminSecret) ? {} : { 'X-Hasura-Admin-Secret': this.authOptions.adminSecret }),
+                ...(isNil(this.authOptions.authRole)
+                    ? {}
+                    : { 'X-Hasura-Role': this.authOptions.authRole.role, 'X-Hasura-User-Id': this.authOptions.authRole.userId }),
+            };
+        }
+        async mutation(operation, fields, variables) {
+            const resultQuery = mutation({
+                operation,
+                variables,
+                fields: GraphQLFieldHelper.ConvertModelFieldsToGraphQLFields(fields),
+            });
+            return this.fetch(resultQuery);
+        }
+        async query(operation, fields, variables) {
+            const resultQuery = GraphQLFieldHelper.CheckIsGraphQLParams(operation)
+                ? query(operation.map((option) => ({
+                    operation: option.operation,
+                    variables: option.variables,
+                    fields: GraphQLFieldHelper.ConvertModelFieldsToGraphQLFields(option.fields),
+                })))
+                : query({
+                    operation,
+                    variables,
+                    fields: GraphQLFieldHelper.ConvertModelFieldsToGraphQLFields(fields),
+                });
+            return this.fetch(resultQuery);
+        }
+        async fetch(params) {
+            const headers = this.headers;
+            const response = await fetch(`${this.endpoint}`, {
+                method: 'POST',
+                body: JSON.stringify(params),
+                headers,
+            });
+            const result = await response.json();
+            if (!isNil(result.errors))
+                throw new Error(JSON.stringify(result.errors));
+            return result.data;
+        }
+        getAttributeGraphQLTypeOf(value) {
+            if (isUUID(value))
+                return 'uuid';
+            if (isString(value))
+                return 'String';
+            if (isBoolean(value))
+                return 'Boolean';
+            if (value instanceof Date)
+                return 'timestamptz';
+            if (isInteger(value))
+                return 'Int';
+            if (isNumber(value))
+                return 'numeric';
+            throw new Error('Type not implemented yet');
+        }
+        checkIfIsDateTimeAndParse(value) {
+            if (!/^\d{4}-(0[1-9]|1[0-2])-(0[1-9]|[12][0-9]|3[01])$/.test(value))
+                return value;
+            const date = parseISO(value);
+            if (isNaN(date.getTime()))
+                return value;
+            return date;
+        }
+        convertDataFromHasura(data) {
+            const plain = GraphQLFieldHelper.ConvertFieldValueFrom(data, this.fields);
+            return this.model.toInstance(plain);
+        }
+        convertDataToHasura(instance, update = false) {
+            return GraphQLFieldHelper.ConvertFieldValueTo(instance, this.fields, update);
+        }
+    };
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"with-hasura-graphql.mixin.js","sourceRoot":"","sources":["../../../../../../projects/connect/src/infra/hasura-graphql/mixins/with-hasura-graphql.mixin.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAA;AACnD,OAAO,KAAK,MAAM,YAAY,CAAA;AAG9B,OAAO,EACL,SAAS,EACT,SAAS,EACT,KAAK,EACL,KAAK,EACL,QAAQ,EACR,QAAQ,EACR,MAAM,EAGN,QAAQ,GACT,MAAM,gBAAgB,CAAA;AAUvB,OAAO,EAAE,kBAAkB,EAAE,MAAM,WAAW,CAAA;AAU9C,MAAM,CAAC,MAAM,iBAAiB,GAAG,CAC/B,SAAY,EACqG,EAAE;IACnH,OAAO,MAAM,kBAAmB,SAAQ,SAAS;QAkB/C,YAAY,GAAG,MAAM;YACnB,MAAM,OAAO,GAA6B,MAAM,CAAC,CAAC,CAAC,CAAA;YAEnD,KAAK,CAAC,GAAG,MAAM,CAAC,CAAA;YAEhB,IAAI,CAAC,SAAS,GAAG,OAAO,CAAC,SAAS,CAAA;YAClC,IAAI,CAAC,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAA;YAChC,IAAI,CAAC,WAAW,GAAG,OAAO,CAAC,WAAW,CAAA;YACtC,IAAI,CAAC,KAAK,GAAG,OAAO,CAAC,KAAK,CAAA;YAC1B,IAAI,CAAC,MAAM,GAAG,OAAO,CAAC,MAAM,IAAK,IAAI,CAAC,KAAK,CAAC,iBAAgD,CAAA;QAC9F,CAAC;QArBD,IAAI,OAAO;YACT,OAAO;gBACL,cAAc,EAAE,kBAAkB;gBAClC,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC,WAAW,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,aAAa,EAAE,IAAI,CAAC,WAAW,CAAC,SAAS,EAAE,CAAC;gBAC3F,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC,WAAW,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,uBAAuB,EAAE,IAAI,CAAC,WAAW,CAAC,WAAW,EAAE,CAAC;gBACzG,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC,WAAW,CAAC,QAAQ,CAAC;oBAClC,CAAC,CAAC,EAAE;oBACJ,CAAC,CAAC,EAAE,eAAe,EAAE,IAAI,CAAC,WAAW,CAAC,QAAQ,CAAC,IAAI,EAAE,kBAAkB,EAAE,IAAI,CAAC,WAAW,CAAC,QAAQ,CAAC,MAAM,EAAE,CAAC;aAC/G,CAAA;QACH,CAAC;QAcD,KAAK,CAAC,QAAQ,CACZ,SAAiB,EACjB,MAAmC,EACnC,SAA2B;YAE3B,MAAM,WAAW,GAAG,QAAQ,CAAC;gBAC3B,SAAS;gBACT,SAAS;gBACT,MAAM,EAAE,kBAAkB,CAAC,iCAAiC,CAAC,MAAM,CAAC;aACrE,CAAC,CAAA;YAEF,OAAO,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,CAAA;QAChC,CAAC;QAED,KAAK,CAAC,KAAK,CACT,SAA0C,EAC1C,MAAmC,EACnC,SAA2B;YAE3B,MAAM,WAAW,GAAG,kBAAkB,CAAC,oBAAoB,CAAC,SAAS,CAAC;gBACpE,CAAC,CAAC,KAAK,CACH,SAAS,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC;oBACzB,SAAS,EAAE,MAAM,CAAC,SAAS;oBAC3B,SAAS,EAAE,MAAM,CAAC,SAAS;oBAC3B,MAAM,EAAE,kBAAkB,CAAC,iCAAiC,CAAC,MAAM,CAAC,MAAM,CAAC;iBAC5E,CAAC,CAAC,CACJ;gBACH,CAAC,CAAC,KAAK,CAAC;oBACJ,SAAS;oBACT,SAAS;oBACT,MAAM,EAAE,kBAAkB,CAAC,iCAAiC,CAAC,MAAM,CAAC;iBACrE,CAAC,CAAA;YAEN,OAAO,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,CAAA;QAChC,CAAC;QAED,KAAK,CAAC,KAAK,CAAqB,MAAyC;YACvE,MAAM,OAAO,GAAG,IAAI,CAAC,OAAO,CAAA;YAC5B,MAAM,QAAQ,GAAG,MAAM,KAAK,CAAC,GAAG,IAAI,CAAC,QAAQ,EAAE,EAAE;gBAC/C,MAAM,EAAE,MAAM;gBACd,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC;gBAC5B,OAAO;aACR,CAAC,CAAA;YACF,MAAM,MAAM,GAAQ,MAAM,QAAQ,CAAC,IAAI,EAAE,CAAA;YAEzC,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC;gBAAE,MAAM,IAAI,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAA;YAEzE,OAAO,MAAM,CAAC,IAAI,CAAA;QACpB,CAAC;QAED,yBAAyB,CAAY,KAAgB;YACnD,IAAI,MAAM,CAAC,KAAY,CAAC;gBAAE,OAAO,MAAM,CAAA;YACvC,IAAI,QAAQ,CAAC,KAAK,CAAC;gBAAE,OAAO,QAAQ,CAAA;YACpC,IAAI,SAAS,CAAC,KAAK,CAAC;gBAAE,OAAO,SAAS,CAAA;YACtC,IAAI,KAAK,YAAY,IAAI;gBAAE,OAAO,aAAa,CAAA;YAC/C,IAAI,SAAS,CAAC,KAAK,CAAC;gBAAE,OAAO,KAAK,CAAA;YAClC,IAAI,QAAQ,CAAC,KAAK,CAAC;gBAAE,OAAO,SAAS,CAAA;YAErC,MAAM,IAAI,KAAK,CAAC,0BAA0B,CAAC,CAAA;QAC7C,CAAC;QAED,yBAAyB,CAAC,KAAa;YACrC,IAAI,CAAC,kDAAkD,CAAC,IAAI,CAAC,KAAK,CAAC;gBAAE,OAAO,KAAK,CAAA;YAEjF,MAAM,IAAI,GAAG,QAAQ,CAAC,KAAK,CAAC,CAAA;YAE5B,IAAI,KAAK,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC;gBAAE,OAAO,KAAK,CAAA;YAEvC,OAAO,IAAI,CAAA;QACb,CAAC;QAED,qBAAqB,CAAC,IAAqC;YACzD,MAAM,KAAK,GAAG,kBAAkB,CAAC,qBAAqB,CAAC,IAAI,EAAE,IAAI,CAAC,MAAM,CAAC,CAAA;YAEzE,OAAO,IAAI,CAAC,KAAK,CAAC,UAAU,CAAC,KAAK,CAAC,CAAA;QACrC,CAAC;QAED,mBAAmB,CAAC,QAAe,EAAE,MAAM,GAAG,KAAK;YACjD,OAAO,kBAAkB,CAAC,mBAAmB,CAAC,QAAQ,EAAE,IAAI,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;QAC9E,CAAC;KACF,CAAA;AACH,CAAC,CAAA","sourcesContent":["import { mutation, query } from 'gql-query-builder'\nimport fetch from 'node-fetch'\n\nimport { BaseModelBuilder, ModelBaseStructure } from '../../../domain'\nimport {\n  isBoolean,\n  isInteger,\n  isNaN,\n  isNil,\n  isNumber,\n  isString,\n  isUUID,\n  MergeConstructorParams,\n  MixinCtor,\n  parseISO,\n} from '../../../utils'\nimport {\n  GraphQLParams,\n  GraphQLRepository,\n  HasuraGraphQLAuthOptions,\n  HasuraGraphQLFields,\n  HasuraGraphQLHeaders,\n  VariableOptions,\n} from '../types'\n\nimport { GraphQLFieldHelper } from './helpers'\n\nexport type ConstructorParams<Model extends ModelBaseStructure> = {\n  tableName: string\n  model: BaseModelBuilder<Model>\n  fields: HasuraGraphQLFields<Model>\n  endpoint: string\n  authOptions: HasuraGraphQLAuthOptions\n}\n\nexport const withHasuraGraphQL = <MBase extends ModelBaseStructure, T extends MixinCtor = MixinCtor>(\n  MixinBase: T,\n): MixinCtor<GraphQLRepository<MBase>, MergeConstructorParams<ConstructorParams<MBase>, ConstructorParameters<T>>> => {\n  return class HasuraGraphQLMixin extends MixinBase implements GraphQLRepository<MBase> {\n    tableName: string\n    endpoint: string\n    authOptions: HasuraGraphQLAuthOptions\n    model: BaseModelBuilder<MBase>\n    fields: HasuraGraphQLFields<MBase>\n\n    get headers(): HasuraGraphQLHeaders {\n      return {\n        'Content-Type': 'application/json',\n        ...(isNil(this.authOptions.authToken) ? {} : { Authorization: this.authOptions.authToken }),\n        ...(isNil(this.authOptions.adminSecret) ? {} : { 'X-Hasura-Admin-Secret': this.authOptions.adminSecret }),\n        ...(isNil(this.authOptions.authRole)\n          ? {}\n          : { 'X-Hasura-Role': this.authOptions.authRole.role, 'X-Hasura-User-Id': this.authOptions.authRole.userId }),\n      }\n    }\n\n    constructor(...params) {\n      const options: ConstructorParams<MBase> = params[0]\n\n      super(...params)\n\n      this.tableName = options.tableName\n      this.endpoint = options.endpoint\n      this.authOptions = options.authOptions\n      this.model = options.model\n      this.fields = options.fields || (this.model.identifiersFields as HasuraGraphQLFields<MBase>)\n    }\n\n    async mutation<ReturnFields = any>(\n      operation: string,\n      fields?: HasuraGraphQLFields<MBase>,\n      variables?: VariableOptions,\n    ): Promise<ReturnFields> {\n      const resultQuery = mutation({\n        operation,\n        variables,\n        fields: GraphQLFieldHelper.ConvertModelFieldsToGraphQLFields(fields),\n      })\n\n      return this.fetch(resultQuery)\n    }\n\n    async query<ReturnFields = any>(\n      operation: string | GraphQLParams<MBase>[],\n      fields?: HasuraGraphQLFields<MBase>,\n      variables?: VariableOptions,\n    ): Promise<ReturnFields> {\n      const resultQuery = GraphQLFieldHelper.CheckIsGraphQLParams(operation)\n        ? query(\n            operation.map((option) => ({\n              operation: option.operation,\n              variables: option.variables,\n              fields: GraphQLFieldHelper.ConvertModelFieldsToGraphQLFields(option.fields),\n            })),\n          )\n        : query({\n            operation,\n            variables,\n            fields: GraphQLFieldHelper.ConvertModelFieldsToGraphQLFields(fields),\n          })\n\n      return this.fetch(resultQuery)\n    }\n\n    async fetch<ReturnFields = any>(params: { variables: any; query: string }): Promise<ReturnFields> {\n      const headers = this.headers\n      const response = await fetch(`${this.endpoint}`, {\n        method: 'POST',\n        body: JSON.stringify(params),\n        headers,\n      })\n      const result: any = await response.json()\n\n      if (!isNil(result.errors)) throw new Error(JSON.stringify(result.errors))\n\n      return result.data\n    }\n\n    getAttributeGraphQLTypeOf<FieldType>(value: FieldType): string {\n      if (isUUID(value as any)) return 'uuid'\n      if (isString(value)) return 'String'\n      if (isBoolean(value)) return 'Boolean'\n      if (value instanceof Date) return 'timestamptz'\n      if (isInteger(value)) return 'Int'\n      if (isNumber(value)) return 'numeric'\n\n      throw new Error('Type not implemented yet')\n    }\n\n    checkIfIsDateTimeAndParse(value: string): Date | string {\n      if (!/^\\d{4}-(0[1-9]|1[0-2])-(0[1-9]|[12][0-9]|3[01])$/.test(value)) return value\n\n      const date = parseISO(value)\n\n      if (isNaN(date.getTime())) return value\n\n      return date\n    }\n\n    convertDataFromHasura(data: Record<string, string | number>): MBase {\n      const plain = GraphQLFieldHelper.ConvertFieldValueFrom(data, this.fields)\n\n      return this.model.toInstance(plain)\n    }\n\n    convertDataToHasura(instance: MBase, update = false): Record<string, string | number> {\n      return GraphQLFieldHelper.ConvertFieldValueTo(instance, this.fields, update)\n    }\n  }\n}\n"]}

package/esm2020/infra/hasura-graphql/mixins/with-update-hasura-graphql.mixin.mjs

@@ -0,0 +1,58 @@
+import { BaseModel, UpdateOptionActions, } from '../../../domain';
+import { isNil } from '../../../utils';
+import { AttributeOptionHelper } from './helpers';
+export const withUpdateHasuraGraphQL = (MixinBase) => {
+    const getValueByAction = (options) => {
+        if (options instanceof BaseModel)
+            return options.toPlain();
+        if (isNil(options?.action))
+            return options;
+        if ([UpdateOptionActions.REMOVE_FIELD.toString(), UpdateOptionActions.NULL.toString()].includes(options.action))
+            return null;
+        return options.value;
+    };
+    return class UpdateHasuraGraphQLMixin extends MixinBase {
+        constructor(...params) {
+            const options = params?.[0];
+            super(...params);
+            this.updateGraphQLOperation = options?.updateGraphQLOperation || `update_${this.tableName}_by_pk`;
+            this.updateGraphQLObjectType = options?.updateGraphQLObjectType || `${this.tableName}_set_input`;
+            this.updateGraphQLPKType = options?.updateGraphQLPKType || `${this.tableName}_pk_columns_input`;
+        }
+        async update(data) {
+            const plainData = this.paramsToPlain(data);
+            await this.mutation(this.updateGraphQLOperation, this.model.identifiersFields.map((field) => AttributeOptionHelper.FindByAttribute(field, this.fields).columnName), {
+                _set: {
+                    type: this.updateGraphQLObjectType,
+                    value: this.convertDataToHasura(this.model.toInstance(plainData), true),
+                    required: true,
+                },
+                pk_columns: { type: this.updateGraphQLPKType, value: this.getUpdateModelKeys(plainData), required: true },
+            });
+            return this.model.toInstance(plainData);
+        }
+        paramsToPlain(params) {
+            const model = this.model;
+            if (model.isModel(params))
+                return params.toPlain();
+            return Object.keys(params).reduce((data, currentKey) => ({
+                ...data,
+                ...(params[currentKey] !== undefined && { [currentKey]: getValueByAction(params[currentKey]) }),
+            }), {});
+        }
+        getUpdateModelKeys(data) {
+            const instance = this.model.toInstance(data);
+            return this.model.identifiersFields.reduce((ids, identifier) => {
+                if (isNil(instance[identifier]))
+                    return ids;
+                const columnOption = AttributeOptionHelper.FindByAttribute(identifier, this.fields);
+                const value = columnOption?.to?.(data[identifier.toString()], instance) || data[columnOption.attributeName];
+                return {
+                    ...ids,
+                    [columnOption.columnName]: value,
+                };
+            }, {});
+        }
+    };
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"with-update-hasura-graphql.mixin.js","sourceRoot":"","sources":["../../../../../../projects/connect/src/infra/hasura-graphql/mixins/with-update-hasura-graphql.mixin.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  BaseModel,\n  ModelBaseStructure,\n  NonFunctionAndIdentifierProperties,\n  RepositoryUpdateParams,\n  UpdateOptionActions,\n  UpdateOptions,\n  UpdateRepository,\n} from '../../../domain'\nimport { isNil, MergeConstructorParams, MixinCtor } from '../../../utils'\nimport { GraphQLRepository, HasuraGraphQLFields } from '../types'\n\nimport { AttributeOptionHelper } from './helpers'\n\nexport type UpdateHasuraGraphQLRepositoryType<MBase extends ModelBaseStructure> = UpdateRepository<MBase> & {\n  paramsToPlain(params: RepositoryUpdateParams<MBase>): Partial<MBase>\n}\n\nexport type UpdateConstructorParams = {\n  updateGraphQLOperation?: string\n  updateGraphQLObjectType?: string\n  updateGraphQLPKType?: string\n}\n\nexport const withUpdateHasuraGraphQL = <\n  MBase extends ModelBaseStructure,\n  TMixinBase extends MixinCtor<GraphQLRepository<MBase>>,\n>(\n  MixinBase: MixinCtor<GraphQLRepository<MBase>> & TMixinBase,\n): MixinCtor<\n  GraphQLRepository<MBase> & UpdateHasuraGraphQLRepositoryType<MBase> & InstanceType<TMixinBase>,\n  MergeConstructorParams<UpdateConstructorParams, ConstructorParameters<TMixinBase>>\n> => {\n  const getValueByAction = (options: UpdateOptions<MBase>): unknown => {\n    if (options instanceof BaseModel) return options.toPlain()\n    if (isNil(options?.action)) return options\n    if ([UpdateOptionActions.REMOVE_FIELD.toString(), UpdateOptionActions.NULL.toString()].includes(options.action))\n      return null\n\n    return options.value\n  }\n\n  return class UpdateHasuraGraphQLMixin extends MixinBase implements UpdateRepository<MBase> {\n    updateGraphQLOperation: string\n    updateGraphQLObjectType: string\n    updateGraphQLPKType: string\n\n    constructor(...params) {\n      const options: UpdateConstructorParams = params?.[0]\n\n      super(...params)\n\n      this.updateGraphQLOperation = options?.updateGraphQLOperation || `update_${this.tableName}_by_pk`\n      this.updateGraphQLObjectType = options?.updateGraphQLObjectType || `${this.tableName}_set_input`\n      this.updateGraphQLPKType = options?.updateGraphQLPKType || `${this.tableName}_pk_columns_input`\n    }\n\n    async update(data: RepositoryUpdateParams<MBase>): Promise<MBase> {\n      const plainData = this.paramsToPlain(data)\n\n      await this.mutation(\n        this.updateGraphQLOperation,\n        this.model.identifiersFields.map(\n          (field) => AttributeOptionHelper.FindByAttribute(field, this.fields).columnName,\n        ) as HasuraGraphQLFields<MBase>,\n        {\n          _set: {\n            type: this.updateGraphQLObjectType,\n            value: this.convertDataToHasura(this.model.toInstance(plainData), true),\n            required: true,\n          },\n          pk_columns: { type: this.updateGraphQLPKType, value: this.getUpdateModelKeys(plainData), required: true },\n        },\n      )\n\n      return this.model.toInstance(plainData)\n    }\n\n    paramsToPlain(params: RepositoryUpdateParams<MBase>): Partial<MBase> {\n      const model = this.model\n\n      if (model.isModel(params)) return params.toPlain()\n\n      return Object.keys(params).reduce(\n        (data, currentKey) => ({\n          ...data,\n          ...(params[currentKey] !== undefined && { [currentKey]: getValueByAction(params[currentKey]) }),\n        }),\n        {},\n      )\n    }\n\n    getUpdateModelKeys(data: Partial<MBase>): NonFunctionAndIdentifierProperties<MBase> {\n      const instance = this.model.toInstance(data)\n\n      return this.model.identifiersFields.reduce((ids, identifier) => {\n        if (isNil(instance[identifier])) return ids\n\n        const columnOption = AttributeOptionHelper.FindByAttribute(identifier, this.fields)\n        const value = columnOption?.to?.(data[identifier.toString()], instance) || data[columnOption.attributeName]\n\n        return {\n          ...ids,\n          [columnOption.columnName]: value,\n        }\n      }, {} as NonFunctionAndIdentifierProperties<MBase>)\n    }\n  } as any\n}\n"]}

package/{esm2015/infra/hasura-graphql/models/kit-product-hasura-graphql.js → esm2020/infra/hasura-graphql/models/kit-product-hasura-graphql.mjs}

@@ -12,4 +12,4 @@ __decorate([
     Type(() => ProductHasuraGraphQL),
     __metadata("design:type", ProductHasuraGraphQL)
 ], KitProductHasuraGraphQL.prototype, "product", void 0);
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoia2l0LXByb2R1Y3QtaGFzdXJhLWdyYXBocWwuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9jb25uZWN0L3NyYy9pbmZyYS9oYXN1cmEtZ3JhcGhxbC9tb2RlbHMva2l0LXByb2R1Y3QtaGFzdXJhLWdyYXBocWwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBLE9BQU8sRUFBRSxJQUFJLEVBQUUsTUFBTSxtQkFBbUIsQ0FBQTtBQUV4QyxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0saUJBQWlCLENBQUE7QUFFNUMsT0FBTyxFQUFFLG9CQUFvQixFQUFFLE1BQU0sMEJBQTBCLENBQUE7QUFFL0QsTUFBTSxPQUFPLHVCQUF3QixTQUFRLFVBQVU7Q0FNdEQ7QUFKQztJQURDLElBQUksQ0FBQyxHQUFHLEVBQUUsQ0FBQyxvQkFBb0IsQ0FBQzs4QkFDNUIsb0JBQW9CO29EQUFBO0FBR3pCO0lBREMsSUFBSSxDQUFDLEdBQUcsRUFBRSxDQUFDLG9CQUFvQixDQUFDOzhCQUN4QixvQkFBb0I7d0RBQUEiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBUeXBlIH0gZnJvbSAnY2xhc3MtdHJhbnNmb3JtZXInXG5cbmltcG9ydCB7IEtpdFByb2R1Y3QgfSBmcm9tICcuLi8uLi8uLi9kb21haW4nXG5cbmltcG9ydCB7IFByb2R1Y3RIYXN1cmFHcmFwaFFMIH0gZnJvbSAnLi9wcm9kdWN0LWhhc3VyYS1ncmFwaHFsJ1xuXG5leHBvcnQgY2xhc3MgS2l0UHJvZHVjdEhhc3VyYUdyYXBoUUwgZXh0ZW5kcyBLaXRQcm9kdWN0IHtcbiAgQFR5cGUoKCkgPT4gUHJvZHVjdEhhc3VyYUdyYXBoUUwpXG4gIGtpdDogUHJvZHVjdEhhc3VyYUdyYXBoUUxcblxuICBAVHlwZSgoKSA9PiBQcm9kdWN0SGFzdXJhR3JhcGhRTClcbiAgcHJvZHVjdDogUHJvZHVjdEhhc3VyYUdyYXBoUUxcbn1cbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoia2l0LXByb2R1Y3QtaGFzdXJhLWdyYXBocWwuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9jb25uZWN0L3NyYy9pbmZyYS9oYXN1cmEtZ3JhcGhxbC9tb2RlbHMva2l0LXByb2R1Y3QtaGFzdXJhLWdyYXBocWwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBLE9BQU8sRUFBRSxJQUFJLEVBQUUsTUFBTSxtQkFBbUIsQ0FBQTtBQUV4QyxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0saUJBQWlCLENBQUE7QUFFNUMsT0FBTyxFQUFFLG9CQUFvQixFQUFFLE1BQU0sMEJBQTBCLENBQUE7QUFFL0QsTUFBTSxPQUFPLHVCQUF3QixTQUFRLFVBQVU7Q0FNdEQ7QUFMQztJQUFDLElBQUksQ0FBQyxHQUFHLEVBQUUsQ0FBQyxvQkFBb0IsQ0FBQzs4QkFDNUIsb0JBQW9CO29EQUFBO0FBRXpCO0lBQUMsSUFBSSxDQUFDLEdBQUcsRUFBRSxDQUFDLG9CQUFvQixDQUFDOzhCQUN4QixvQkFBb0I7d0RBQUEiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBUeXBlIH0gZnJvbSAnY2xhc3MtdHJhbnNmb3JtZXInXG5cbmltcG9ydCB7IEtpdFByb2R1Y3QgfSBmcm9tICcuLi8uLi8uLi9kb21haW4nXG5cbmltcG9ydCB7IFByb2R1Y3RIYXN1cmFHcmFwaFFMIH0gZnJvbSAnLi9wcm9kdWN0LWhhc3VyYS1ncmFwaHFsJ1xuXG5leHBvcnQgY2xhc3MgS2l0UHJvZHVjdEhhc3VyYUdyYXBoUUwgZXh0ZW5kcyBLaXRQcm9kdWN0IHtcbiAgQFR5cGUoKCkgPT4gUHJvZHVjdEhhc3VyYUdyYXBoUUwpXG4gIGtpdDogUHJvZHVjdEhhc3VyYUdyYXBoUUxcblxuICBAVHlwZSgoKSA9PiBQcm9kdWN0SGFzdXJhR3JhcGhRTClcbiAgcHJvZHVjdDogUHJvZHVjdEhhc3VyYUdyYXBoUUxcbn1cbiJdfQ==

package/{esm2015/infra/hasura-graphql/models/product-hasura-graphql.js → esm2020/infra/hasura-graphql/models/product-hasura-graphql.mjs}

@@ -8,4 +8,4 @@ __decorate([
     Type(() => KitProductHasuraGraphQL),
     __metadata("design:type", Array)
 ], ProductHasuraGraphQL.prototype, "kitProducts", void 0);
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJvZHVjdC1oYXN1cmEtZ3JhcGhxbC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2Nvbm5lY3Qvc3JjL2luZnJhL2hhc3VyYS1ncmFwaHFsL21vZGVscy9wcm9kdWN0LWhhc3VyYS1ncmFwaHFsLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQSxPQUFPLEVBQUUsSUFBSSxFQUFFLE1BQU0sbUJBQW1CLENBQUE7QUFFeEMsT0FBTyxFQUFFLE9BQU8sRUFBRSxNQUFNLGlCQUFpQixDQUFBO0FBRXpDLE9BQU8sRUFBRSx1QkFBdUIsRUFBRSxNQUFNLDhCQUE4QixDQUFBO0FBRXRFLE1BQU0sT0FBTyxvQkFBcUIsU0FBUSxPQUFPO0NBYWhEO0FBREM7SUFEQyxJQUFJLENBQUMsR0FBRyxFQUFFLENBQUMsdUJBQXVCLENBQUM7O3lEQUNHIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgVHlwZSB9IGZyb20gJ2NsYXNzLXRyYW5zZm9ybWVyJ1xuXG5pbXBvcnQgeyBQcm9kdWN0IH0gZnJvbSAnLi4vLi4vLi4vZG9tYWluJ1xuXG5pbXBvcnQgeyBLaXRQcm9kdWN0SGFzdXJhR3JhcGhRTCB9IGZyb20gJy4va2l0LXByb2R1Y3QtaGFzdXJhLWdyYXBocWwnXG5cbmV4cG9ydCBjbGFzcyBQcm9kdWN0SGFzdXJhR3JhcGhRTCBleHRlbmRzIFByb2R1Y3Qge1xuICBmaXJlc3RvcmVJZD86IHN0cmluZ1xuICBmdWxsUHJpY2U/OiBudW1iZXJcbiAgc3Vic2NyaWJlckRpc2NvdW50UGVyY2VudGFnZT86IG51bWJlclxuICBzdWJzY3JpYmVyUHJpY2U/OiBudW1iZXJcbiAgcHJvZHVjdElkPzogbnVtYmVyXG4gIGRpZmZlcmVudGlhbHM/OiBzdHJpbmdcbiAgd2hvTXVzdFVzZT86IHN0cmluZ1xuICBob3dUb1VzZT86IHN0cmluZ1xuICBicmFuZERlc2NyaXB0aW9uPzogc3RyaW5nXG5cbiAgQFR5cGUoKCkgPT4gS2l0UHJvZHVjdEhhc3VyYUdyYXBoUUwpXG4gIGtpdFByb2R1Y3RzPzogS2l0UHJvZHVjdEhhc3VyYUdyYXBoUUxbXVxufVxuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJvZHVjdC1oYXN1cmEtZ3JhcGhxbC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2Nvbm5lY3Qvc3JjL2luZnJhL2hhc3VyYS1ncmFwaHFsL21vZGVscy9wcm9kdWN0LWhhc3VyYS1ncmFwaHFsLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQSxPQUFPLEVBQUUsSUFBSSxFQUFFLE1BQU0sbUJBQW1CLENBQUE7QUFFeEMsT0FBTyxFQUFFLE9BQU8sRUFBRSxNQUFNLGlCQUFpQixDQUFBO0FBRXpDLE9BQU8sRUFBRSx1QkFBdUIsRUFBRSxNQUFNLDhCQUE4QixDQUFBO0FBRXRFLE1BQU0sT0FBTyxvQkFBcUIsU0FBUSxPQUFPO0NBYWhEO0FBRkM7SUFBQyxJQUFJLENBQUMsR0FBRyxFQUFFLENBQUMsdUJBQXVCLENBQUM7O3lEQUNHIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgVHlwZSB9IGZyb20gJ2NsYXNzLXRyYW5zZm9ybWVyJ1xuXG5pbXBvcnQgeyBQcm9kdWN0IH0gZnJvbSAnLi4vLi4vLi4vZG9tYWluJ1xuXG5pbXBvcnQgeyBLaXRQcm9kdWN0SGFzdXJhR3JhcGhRTCB9IGZyb20gJy4va2l0LXByb2R1Y3QtaGFzdXJhLWdyYXBocWwnXG5cbmV4cG9ydCBjbGFzcyBQcm9kdWN0SGFzdXJhR3JhcGhRTCBleHRlbmRzIFByb2R1Y3Qge1xuICBmaXJlc3RvcmVJZD86IHN0cmluZ1xuICBmdWxsUHJpY2U/OiBudW1iZXJcbiAgc3Vic2NyaWJlckRpc2NvdW50UGVyY2VudGFnZT86IG51bWJlclxuICBzdWJzY3JpYmVyUHJpY2U/OiBudW1iZXJcbiAgcHJvZHVjdElkPzogbnVtYmVyXG4gIGRpZmZlcmVudGlhbHM/OiBzdHJpbmdcbiAgd2hvTXVzdFVzZT86IHN0cmluZ1xuICBob3dUb1VzZT86IHN0cmluZ1xuICBicmFuZERlc2NyaXB0aW9uPzogc3RyaW5nXG5cbiAgQFR5cGUoKCkgPT4gS2l0UHJvZHVjdEhhc3VyYUdyYXBoUUwpXG4gIGtpdFByb2R1Y3RzPzogS2l0UHJvZHVjdEhhc3VyYUdyYXBoUUxbXVxufVxuIl19

package/esm2020/infra/hasura-graphql/repositories/catalog/category-hasura-graphql.repository.mjs

@@ -0,0 +1,219 @@
+import { Category, Where, } from '../../../../domain';
+import { DuplicatedResultsError, NotFoundError } from '../../../../errors';
+import { Base, omit } from '../../../../utils';
+import { HasuraGraphQLColumnType } from '../../enums';
+import { withCrudHasuraGraphQL, withHasuraGraphQL } from '../../mixins';
+export class CategoryHasuraGraphQLRepository extends withCrudHasuraGraphQL(withHasuraGraphQL(Base)) {
+    constructor(endpoint, authOptions, productRepository) {
+        super({
+            tableName: 'category',
+            model: Category,
+            endpoint,
+            authOptions,
+            fields: [
+                { id: { columnName: 'id', to: (value) => +value, from: (value) => value.toString() } },
+                { firestoreId: { columnName: 'firestore_id' } },
+                'name',
+                'description',
+                'image',
+                'published',
+                'shop',
+                'slug',
+                { brandCategory: { columnName: 'brand_category' } },
+                { brandCategoryBanner: { columnName: 'brand_banner' } },
+                { brandCategoryBannerMobile: { columnName: 'brand_banner_mobile' } },
+                { brandLogo: { columnName: 'brand_logo' } },
+                { brandCondition: { columnName: 'brand_condition' } },
+                {
+                    conditions: {
+                        columnName: 'tag_condition',
+                        type: HasuraGraphQLColumnType.Jsonb,
+                        from: (tags, row) => ({ brand: row.brand_condition, tags: Array.isArray(tags) ? tags : [] }),
+                        bindPersistData: (value) => {
+                            return {
+                                brand_condition: value.brand,
+                                tag_condition: value?.tags || [],
+                            };
+                        },
+                        bindFindFilter: (sentence) => {
+                            return {
+                                ...(sentence.brand ? { brand_condition: sentence.brand } : {}),
+                                ...(sentence.tags ? { tag_condition: sentence.tags } : {}),
+                            };
+                        },
+                    },
+                },
+                'filters',
+                { createdAt: { columnName: 'created_at' } },
+                { updatedAt: { columnName: 'updated_at' } },
+                {
+                    products: {
+                        columnName: 'products',
+                        fields: ['product_id'],
+                        from: (value) => value.map((product) => product.product_id.toString()),
+                        to: (productIds) => productIds.map((productId) => ({
+                            product_id: +productId,
+                        })),
+                    },
+                },
+                {
+                    metadata: {
+                        columnName: 'metadata',
+                        fields: ['title', 'description'],
+                        bindPersistData: (value) => ({
+                            metadata: { data: value },
+                        }),
+                    },
+                },
+            ],
+        });
+        this.productRepository = productRepository;
+    }
+    async create(params) {
+        const { metadata, ...data } = params;
+        return super.create({ ...data, metadata: metadata || { description: null, title: null } });
+    }
+    async get(identifiers) {
+        return Number.isNaN(+identifiers.id)
+            ? (await this.find({ filters: { firestoreId: identifiers.id } })).data?.[0]
+            : super.get(identifiers);
+    }
+    async update(params) {
+        const { products, id: checkId, metadata, ...data } = params;
+        const plainData = this.paramsToPlain({ id: checkId });
+        const id = await this.getId(plainData.id);
+        const category = await super.update({ id, ...data });
+        category.products = products && (await this.updateProducts(+id, { products }));
+        category.metadata = metadata && (await this.updateMetadata(+id, { metadata }));
+        return category;
+    }
+    async getCategoryBySlug(slug, shop) {
+        if (!slug)
+            return;
+        const { data, count } = await this.find({ filters: { slug, shop, published: true } });
+        if (count > 1)
+            throw new DuplicatedResultsError('Query returned duplicated values');
+        if (!count)
+            throw new NotFoundError(`Category with slug ${slug} not found`);
+        return data.shift();
+    }
+    async getCategoriesForHome(categoryIds, limit = 4) {
+        if (!categoryIds?.length)
+            return [];
+        const categoriesFirestore = categoryIds.filter((categoryId) => Number.isNaN(+categoryId));
+        const categoriesHasura = categoryIds.filter((categoryId) => +categoryId > 0);
+        const categories = [];
+        if (categoriesFirestore.length)
+            categories.push(...(await this.find({
+                filters: { firestoreId: { operator: Where.IN, value: categoriesFirestore.filter(Boolean) }, published: true },
+            }).then(({ data }) => data)));
+        if (categoriesHasura.length)
+            categories.push(...(await this.find({
+                filters: { id: { operator: Where.IN, value: categoriesHasura.filter(Boolean) }, published: true },
+            }).then(({ data }) => data)));
+        if (!categories.length)
+            return [];
+        const homeSections = await Promise.all(categories.map(async (category) => ({
+            category,
+            products: await this.mountCategory(category, { limit, hasStock: true }),
+        })));
+        return homeSections;
+    }
+    async mountCategory(category, options) {
+        if (!category?.products?.length)
+            return [];
+        const products = [];
+        const { data: productsData } = await this.productRepository.find({
+            filters: {
+                id: { operator: Where.IN, value: category.products },
+                published: true,
+                ...(options?.hasStock ? { stock: { quantity: { operator: Where.GT, value: 0 } } } : {}),
+            },
+            fields: [
+                'id',
+                'name',
+                'slug',
+                'images',
+                'miniatures',
+                'price',
+                'fullPrice',
+                'subscriberDiscountPercentage',
+                'subscriberPrice',
+                'stock',
+                'published',
+                'CEST',
+                'EAN',
+                'NCM',
+                'brand',
+                'costPrice',
+                'hasVariants',
+                'isKit',
+                'sku',
+                'rate',
+                'tags',
+                'type',
+                'shoppingCount',
+            ],
+            ...(options?.limit ? { limits: { limit: options?.limit } } : {}),
+        });
+        products.push(...productsData);
+        return products;
+    }
+    async getId(id) {
+        if (!Number.isNaN(+id))
+            return id;
+        const { data } = await this.find({ filters: { firestoreId: id } });
+        if (data?.[0]?.id)
+            return data?.[0]?.id;
+        throw new NotFoundError(`Category with id ${id} not found`);
+    }
+    async updateProducts(categoryId, { products }) {
+        if ('action' in products && products.action === 'remove') {
+            await this.mutation('delete_category_product', ['affected_rows'], {
+                where: {
+                    type: 'category_product_bool_exp',
+                    required: true,
+                    value: { category_id: { _eq: categoryId } },
+                },
+            });
+            return [];
+        }
+        const plainData = this.paramsToPlain({ products });
+        if (!plainData.products || plainData.products.length <= 0)
+            return [];
+        await this.mutation('delete_category_product', ['affected_rows'], {
+            where: {
+                type: 'category_product_bool_exp',
+                required: true,
+                value: { category_id: { _eq: categoryId } },
+            },
+        });
+        await this.mutation('insert_category_product', ['affected_rows'], {
+            objects: {
+                type: '[category_product_insert_input!]',
+                required: true,
+                value: plainData.products.map((productId) => ({ category_id: categoryId, product_id: productId })),
+            },
+        });
+        return plainData.products;
+    }
+    async updateMetadata(categoryId, { metadata }) {
+        const plainData = this.paramsToPlain({ metadata });
+        if (!plainData.metadata)
+            return;
+        await this.mutation('update_category_metadata_by_pk', ['category_id'], {
+            pk_columns: {
+                value: { category_id: categoryId },
+                type: 'category_metadata_pk_columns_input',
+                required: true,
+            },
+            _set: {
+                value: omit(metadata, ['category_id']),
+                type: 'category_metadata_set_input',
+                required: true,
+            },
+        });
+        return plainData.metadata;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"category-hasura-graphql.repository.js","sourceRoot":"","sources":["../../../../../../../projects/connect/src/infra/hasura-graphql/repositories/catalog/category-hasura-graphql.repository.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  Category,\n  CategoryMetadata,\n  CategoryRepository,\n  CreateRepositoryParams,\n  GetRepositoryParams,\n  Product,\n  Shops,\n  UpdateRepositoryParams,\n  Where,\n} from '../../../../domain'\nimport { DuplicatedResultsError, NotFoundError } from '../../../../errors'\nimport { Base, omit } from '../../../../utils'\nimport { HasuraGraphQLColumnType } from '../../enums'\nimport { withCrudHasuraGraphQL, withHasuraGraphQL } from '../../mixins'\nimport { CategoryHasuraGraphQL } from '../../models'\nimport { HasuraGraphQLAuthOptions } from '../../types'\n\nimport { ProductHasuraGraphQLRepository } from './product-hasura-graphql.repository'\n\nexport class CategoryHasuraGraphQLRepository\n  extends withCrudHasuraGraphQL(withHasuraGraphQL<CategoryHasuraGraphQL>(Base))\n  implements CategoryRepository\n{\n  constructor(\n    endpoint: string,\n    authOptions: HasuraGraphQLAuthOptions,\n    private readonly productRepository: ProductHasuraGraphQLRepository,\n  ) {\n    super({\n      tableName: 'category',\n      model: Category,\n      endpoint,\n      authOptions,\n      fields: [\n        { id: { columnName: 'id', to: (value) => +value, from: (value) => value.toString() } },\n        { firestoreId: { columnName: 'firestore_id' } },\n        'name',\n        'description',\n        'image',\n        'published',\n        'shop',\n        'slug',\n        { brandCategory: { columnName: 'brand_category' } },\n        { brandCategoryBanner: { columnName: 'brand_banner' } },\n        { brandCategoryBannerMobile: { columnName: 'brand_banner_mobile' } },\n        { brandLogo: { columnName: 'brand_logo' } },\n        { brandCondition: { columnName: 'brand_condition' } },\n        {\n          conditions: {\n            columnName: 'tag_condition',\n            type: HasuraGraphQLColumnType.Jsonb,\n            from: (tags: unknown, row) => ({ brand: row.brand_condition, tags: Array.isArray(tags) ? tags : [] }),\n            bindPersistData: (value) => {\n              return {\n                brand_condition: value.brand,\n                tag_condition: value?.tags || [],\n              }\n            },\n            bindFindFilter: (sentence: any) => {\n              return {\n                ...(sentence.brand ? { brand_condition: sentence.brand } : {}),\n                ...(sentence.tags ? { tag_condition: sentence.tags } : {}),\n              }\n            },\n          },\n        },\n        'filters',\n        { createdAt: { columnName: 'created_at' } },\n        { updatedAt: { columnName: 'updated_at' } },\n        {\n          products: {\n            columnName: 'products',\n            fields: ['product_id'],\n            from: (value: { product_id: number }[]) => value.map((product) => product.product_id.toString()),\n            to: (productIds) =>\n              productIds.map((productId) => ({\n                product_id: +productId,\n              })),\n          },\n        },\n        {\n          metadata: {\n            columnName: 'metadata',\n            fields: ['title', 'description'],\n            bindPersistData: (value) => ({\n              metadata: { data: value },\n            }),\n          },\n        },\n      ],\n    })\n  }\n\n  async create(params: CreateRepositoryParams<CategoryHasuraGraphQL>): Promise<CategoryHasuraGraphQL> {\n    const { metadata, ...data } = params\n\n    return super.create({ ...data, metadata: metadata || { description: null, title: null } })\n  }\n\n  async get(identifiers: GetRepositoryParams<CategoryHasuraGraphQL>): Promise<CategoryHasuraGraphQL> {\n    return Number.isNaN(+identifiers.id)\n      ? (await this.find({ filters: { firestoreId: identifiers.id } })).data?.[0]\n      : super.get(identifiers)\n  }\n\n  async update(params: UpdateRepositoryParams<CategoryHasuraGraphQL>): Promise<CategoryHasuraGraphQL> {\n    const { products, id: checkId, metadata, ...data } = params\n    const plainData = this.paramsToPlain({ id: checkId })\n    const id = await this.getId(plainData.id)\n    const category = await super.update({ id, ...data })\n\n    category.products = products && (await this.updateProducts(+id, { products }))\n    category.metadata = metadata && (await this.updateMetadata(+id, { metadata }))\n\n    return category\n  }\n\n  async getCategoryBySlug(slug: string, shop: Shops): Promise<Category> {\n    if (!slug) return\n\n    const { data, count } = await this.find({ filters: { slug, shop, published: true } })\n\n    if (count > 1) throw new DuplicatedResultsError('Query returned duplicated values')\n    if (!count) throw new NotFoundError(`Category with slug ${slug} not found`)\n\n    return data.shift()\n  }\n\n  async getCategoriesForHome(categoryIds: string[], limit = 4): Promise<{ category: Category; products: Product[] }[]> {\n    if (!categoryIds?.length) return []\n\n    const categoriesFirestore = categoryIds.filter((categoryId) => Number.isNaN(+categoryId))\n    const categoriesHasura = categoryIds.filter((categoryId) => +categoryId > 0)\n    const categories = []\n\n    if (categoriesFirestore.length)\n      categories.push(\n        ...(await this.find({\n          filters: { firestoreId: { operator: Where.IN, value: categoriesFirestore.filter(Boolean) }, published: true },\n        }).then(({ data }) => data)),\n      )\n    if (categoriesHasura.length)\n      categories.push(\n        ...(await this.find({\n          filters: { id: { operator: Where.IN, value: categoriesHasura.filter(Boolean) }, published: true },\n        }).then(({ data }) => data)),\n      )\n\n    if (!categories.length) return []\n\n    const homeSections = await Promise.all(\n      categories.map(async (category) => ({\n        category,\n        products: await this.mountCategory(category, { limit, hasStock: true }),\n      })),\n    )\n\n    return homeSections\n  }\n\n  async mountCategory(category: Category, options?: { limit?: number; hasStock?: boolean }): Promise<Product[]> {\n    if (!category?.products?.length) return []\n\n    const products = []\n    const { data: productsData } = await this.productRepository.find({\n      filters: {\n        id: { operator: Where.IN, value: category.products },\n        published: true,\n        ...(options?.hasStock ? { stock: { quantity: { operator: Where.GT, value: 0 } } } : {}),\n      },\n      fields: [\n        'id',\n        'name',\n        'slug',\n        'images',\n        'miniatures',\n        'price',\n        'fullPrice',\n        'subscriberDiscountPercentage',\n        'subscriberPrice',\n        'stock',\n        'published',\n        'CEST',\n        'EAN',\n        'NCM',\n        'brand',\n        'costPrice',\n        'hasVariants',\n        'isKit',\n        'sku',\n        'rate',\n        'tags',\n        'type',\n        'shoppingCount',\n      ],\n      ...(options?.limit ? { limits: { limit: options?.limit } } : {}),\n    })\n\n    products.push(...productsData)\n\n    return products\n  }\n\n  private async getId(id: string): Promise<string> {\n    if (!Number.isNaN(+id)) return id\n\n    const { data } = await this.find({ filters: { firestoreId: id } })\n\n    if (data?.[0]?.id) return data?.[0]?.id\n\n    throw new NotFoundError(`Category with id ${id} not found`)\n  }\n\n  private async updateProducts(\n    categoryId: number,\n    { products }: Pick<UpdateRepositoryParams<CategoryHasuraGraphQL>, 'products'>,\n  ): Promise<CategoryHasuraGraphQL['products']> {\n    if ('action' in products && products.action === 'remove') {\n      await this.mutation('delete_category_product', ['affected_rows'], {\n        where: {\n          type: 'category_product_bool_exp',\n          required: true,\n          value: { category_id: { _eq: categoryId } },\n        },\n      })\n\n      return []\n    }\n\n    const plainData = this.paramsToPlain({ products })\n\n    if (!plainData.products || plainData.products.length <= 0) return []\n\n    await this.mutation('delete_category_product', ['affected_rows'], {\n      where: {\n        type: 'category_product_bool_exp',\n        required: true,\n        value: { category_id: { _eq: categoryId } },\n      },\n    })\n\n    await this.mutation('insert_category_product', ['affected_rows'], {\n      objects: {\n        type: '[category_product_insert_input!]',\n        required: true,\n        value: plainData.products.map((productId) => ({ category_id: categoryId, product_id: productId })),\n      },\n    })\n\n    return plainData.products\n  }\n\n  private async updateMetadata(\n    categoryId: number,\n    { metadata }: Pick<UpdateRepositoryParams<CategoryHasuraGraphQL>, 'metadata'>,\n  ): Promise<CategoryMetadata> {\n    const plainData = this.paramsToPlain({ metadata })\n\n    if (!plainData.metadata) return\n\n    await this.mutation('update_category_metadata_by_pk', ['category_id'], {\n      pk_columns: {\n        value: { category_id: categoryId },\n        type: 'category_metadata_pk_columns_input',\n        required: true,\n      },\n      _set: {\n        value: omit(metadata, ['category_id']),\n        type: 'category_metadata_set_input',\n        required: true,\n      },\n    })\n\n    return plainData.metadata\n  }\n}\n"]}