@nx-ddd/hasura 19.0.0-preview.23 → 19.0.0-preview.25

package/fesm2022/nx-ddd-hasura.mjs

@@ -1,17 +1,19 @@
 import * as i0 from '@angular/core';
 import { inject, Injectable, InjectionToken, importProvidersFrom } from '@angular/core';
-import { Apollo, APOLLO_OPTIONS, ApolloModule } from 'apollo-angular';
+import { Apollo, APOLLO_OPTIONS, ApolloModule, gql } from 'apollo-angular';
 import { HttpLink } from 'apollo-angular/http';
 import { InMemoryCache } from '@apollo/client/cache';
 import { setContext } from '@apollo/client/link/context';
-import { split, ApolloLink, HttpLink as HttpLink$1, InMemoryCache as InMemoryCache$1, gql } from '@apollo/client/core';
+import { split, ApolloLink, HttpLink as HttpLink$1, InMemoryCache as InMemoryCache$1, gql as gql$1 } from '@apollo/client/core';
 import { getMainDefinition } from '@apollo/client/utilities';
 import { makeDI, makeDecoratorFactories, plainToInstanceWithValid } from '@nx-ddd/core';
 import { WebSocketLink } from '@apollo/client/link/ws';
-import { from, of, isObservable, firstValueFrom, filter, distinctUntilChanged, tap, switchMap, lastValueFrom, map } from 'rxjs';
-import { camelCase, snakeCase, isObject, mapKeys, mapValues, get, omitBy, omit, pick } from 'lodash-es';
+import { from, of, isObservable, lastValueFrom, filter, take, distinctUntilChanged, tap, switchMap, map } from 'rxjs';
+import { camelCase as camelCase$1, snakeCase, get, pick, omitBy } from 'lodash-es';
 import { HTTP_INTERCEPTORS, HttpClient } from '@angular/common/http';
 import dayjs from 'dayjs';
+import { format } from 'date-fns';
+import { Repository } from '@nx-ddd/common/domain';
 export { TransformToDayjs } from '@nx-ddd/common/domain';
 export { IsDayjs } from 'class-validator-extended';
 
@@ -20,7 +22,7 @@ function wrap(token) {
 }
 function resolve(getHeaders) {
     const headers$ = wrap(getHeaders());
-    return firstValueFrom(headers$.pipe(filter((headers) => !!headers), distinctUntilChanged(), tap((headers) => console.debug('[resolve] headers:', headers))));
+    return lastValueFrom(headers$.pipe(filter((headers) => !!headers), take(1), distinctUntilChanged(), tap((headers) => console.debug('[resolve] headers:', headers))));
 }
 function buildWebsocketLink(endpoint, getHeaders) {
     return new WebSocketLink({
@@ -75,7 +77,7 @@ const { createDecorator, getAnnotations, } = makeDecoratorFactories((type, field
 function getFlattenFieldAnnotations(T, prefix = '') {
     const annotations = Hasura.getAnnotations(T);
     return (annotations ?? []).reduce((acc, annotation) => {
-        const currentKey = prefix ? camelCase(`${prefix}_${annotation.fieldName}`) : annotation.fieldName;
+        const currentKey = prefix ? camelCase$1(`${prefix}_${annotation.fieldName}`) : annotation.fieldName;
         if (annotation.childType) {
             return {
                 ...acc,
@@ -93,7 +95,7 @@ function getFields(T, options = {
     case: 'snake'
 }) {
     const annotations = Hasura.getAnnotations(T);
-    const changeCase = options?.case === 'snake' ? snakeCase : camelCase;
+    const changeCase = options?.case === 'snake' ? snakeCase : camelCase$1;
     const fields = (annotations ?? []).flatMap((annotation) => {
         const currentKey = changeCase(options?.prefix ? `${options?.prefix}_${annotation.fieldName}` : annotation.fieldName);
         if (annotation.childType) {
@@ -146,20 +148,34 @@ function provideHasuraConfig(config) {
 }
 
 function deepCamelToSnakeCase(obj) {
-    if (Array.isArray(obj)) {
+    if (Array.isArray(obj))
         return obj.map(deepCamelToSnakeCase);
-    }
-    else if (isObject(obj)) {
-        return mapKeys(mapValues(obj, deepCamelToSnakeCase), (_, key) => snakeCase(key));
+    if (obj instanceof Date)
+        return obj;
+    if (obj && typeof obj === "object") {
+        const result = {};
+        for (const key in obj) {
+            if (Object.prototype.hasOwnProperty.call(obj, key))
+                result[snakeCase(key)] = deepCamelToSnakeCase(obj[key]);
+        }
+        return result;
     }
     return obj;
 }
+function camelCase(str) {
+    return str.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
+}
 function deepSnakeToCamelCase(obj) {
-    if (Array.isArray(obj)) {
+    if (Array.isArray(obj))
         return obj.map(deepSnakeToCamelCase);
-    }
-    else if (isObject(obj)) {
-        return mapKeys(mapValues(obj, deepSnakeToCamelCase), (_, key) => key.replace(/_([a-z])/g, (g) => g[1].toUpperCase()));
+    if (obj instanceof Date)
+        return obj;
+    if (obj && typeof obj === "object") {
+        const result = {};
+        for (const key in obj)
+            if (Object.prototype.hasOwnProperty.call(obj, key))
+                result[camelCase(key)] = deepSnakeToCamelCase(obj[key]);
+        return result;
     }
     return obj;
 }
@@ -189,23 +205,54 @@ function getConverter(type) {
 const makeConverter = getConverter;
 class HasuraUtils {
     static toTimestamp(date) {
-        if (!dayjs.isDayjs(date))
+        if (dayjs.isDayjs(date)) {
+            return date.toISOString();
+        }
+        else if (date instanceof Date) {
+            return format(date, 'yyyy-MM-dd HH:mm:ss');
+        }
+        else {
             return null;
-        return date.toISOString();
+        }
+    }
+    static toDate(date) {
+        if (typeof date === 'undefined') {
+            return undefined;
+        }
+        else if (dayjs.isDayjs(date)) {
+            return format(date.toDate(), 'yyyy-MM-dd');
+        }
+        else if (date instanceof Date) {
+            return format(date, 'yyyy-MM-dd');
+        }
+        else if (typeof date === 'string') {
+            return date;
+        }
+        else {
+            return null;
+        }
     }
     static fromHasura(_object, type) {
         const object = deepSnakeToCamelCase(_object);
         return plainToInstanceWithValid(type, object);
     }
+    static toNumber(value) {
+        if (typeof value === 'undefined')
+            return undefined;
+        return isNaN(Number(value)) ? null : Number(value);
+    }
     static toHasura(object, type, { extraFunc = deepCamelToSnakeCase } = {}) {
         const fields = getFlattenFieldAnnotations(type);
         const obj = Object.entries(fields).reduce((acc, [key, annotation]) => {
             const value = get(object, annotation.fieldName);
+            if (typeof value === 'undefined')
+                return acc;
             switch (annotation.type) {
                 case 'text': return { ...acc, [key]: value };
                 case 'timestamp': return { ...acc, [key]: this.toTimestamp(value) };
-                case 'numeric': return { ...acc, [key]: isNaN(Number(value)) ? null : Number(value) };
-                case 'integer': return { ...acc, [key]: isNaN(Number(value)) ? null : Number(value) };
+                case 'date': return { ...acc, [key]: this.toDate(value) };
+                case 'numeric': return { ...acc, [key]: this.toNumber(value) };
+                case 'integer': return { ...acc, [key]: this.toNumber(value) };
                 case 'json': return { ...acc, [key]: value };
                 case 'map': return { ...acc };
                 default: return { ...acc, [key]: value };
@@ -275,6 +322,231 @@ function provideHasuraWithWebSocket(config) {
     ];
 }
 
+class GetQueryPartBuilder {
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    build(params) {
+        const queryName = `${this.config.tableName}_by_pk`;
+        const variableDefinitions = ['$id: String!'];
+        const queryPart = `${queryName}(id: $id) { ${this.config.columns.join(' ')} }`;
+        return { queryPart, variableDefinitions, variables: params, operationName: queryName };
+    }
+    buildMany() {
+        const queryName = this.config.tableName;
+        const queryPart = `${queryName} { ${this.config.columns.join(' ')} }`;
+        return { queryPart, variableDefinitions: [], variables: {}, operationName: queryName };
+    }
+}
+
+function makeSubscription(query) {
+    const { kind, definitions } = query;
+    const subscriptionDefinitions = definitions.map((definition) => {
+        if (definition.kind === 'OperationDefinition' && definition.operation === 'query') {
+            return {
+                ...definition,
+                operation: 'subscription',
+            };
+        }
+        return definition;
+    });
+    return { kind, definitions: subscriptionDefinitions };
+}
+;
+class QueriesBuilder {
+    get;
+    constructor(config) {
+        this.get = new GetQueryPartBuilder(config);
+    }
+    makeSubscription(query) {
+        return makeSubscription(query);
+    }
+    ;
+}
+
+class CreateMutationBuilder {
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    build(data, alias = 'create') {
+        const object = this.convertToObject(data);
+        const mutationName = `insert_${this.config.tableName}`;
+        const variableDefinitions = [`$${alias}: ${this.config.tableName}_insert_input!`];
+        const queryPart = `${alias}: ${mutationName}(objects: [$${alias}]) { affected_rows returning { ${this.config.columns.join(' ')} } }`;
+        const variables = { [alias]: object };
+        return { queryPart, variableDefinitions, variables, operationName: mutationName, alias };
+    }
+    buildMany(data, alias = 'createMany') {
+        const objects = this.convertToObjects(data);
+        const mutationName = `insert_${this.config.tableName}`;
+        const variableDefinitions = [`$${alias}: [${this.config.tableName}_insert_input!]!`];
+        const queryPart = `${alias}: ${mutationName}(objects: $${alias}) { affected_rows returning { ${this.config.columns.join(' ')} } }`;
+        const variables = { [alias]: objects };
+        return { queryPart, variableDefinitions, variables, operationName: mutationName, alias };
+    }
+    convertToObject(item) {
+        const fields = Object.keys(item).map(snakeCase).filter((field) => !['created_at', 'updated_at'].includes(field));
+        const picked = pick(item, [...fields]);
+        return omitBy(picked, (value) => typeof value === 'undefined');
+    }
+    convertToObjects(items) {
+        return items.map((item) => this.convertToObject(item));
+    }
+}
+
+class DeleteMutationBuilder {
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    build({ id }) {
+        const operationName = `delete_${this.config.tableName}`;
+        const queryPart = `${operationName}(where: {id: {_eq: $id}}) { affected_rows }`;
+        const variableDefinitions = ['$id: String!'];
+        return { queryPart, variableDefinitions, variables: { id }, operationName };
+    }
+    buildMany(params, alias = 'deleteMany') {
+        const operationName = `delete_${this.config.tableName}`;
+        const variableDefinitions = [`$${alias}: [String!]!`];
+        const queryPart = `${alias}: ${operationName}(where: {id: {_in: $${alias}}}) { affected_rows }`;
+        const variables = { [alias]: params.map((p) => p.id) };
+        return { queryPart, variableDefinitions, variables, operationName, alias };
+    }
+    buildAll(alias = 'deleteAll') {
+        const operationName = `delete_${this.config.tableName}`;
+        const uniqueAlias = `${alias}_${this.config.tableName}`;
+        const variableDefinitions = [];
+        const queryPart = `${uniqueAlias}: ${operationName}(where: {}) { affected_rows }`;
+        const variables = {};
+        return { queryPart, variableDefinitions, variables, operationName, alias };
+    }
+}
+
+class SaveMutationBuilder {
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    build(data, { operationName = `insert_${this.config.tableName}`, constraint = this.config.pk, columns = this.config.columns, returningColumns = this.config.columns, alias = operationName, } = {}) {
+        const object = this.buildObject(data);
+        const onConflict = this.buildOnConflict(data, constraint, columns);
+        const variableDefinitions = [
+            `$${alias}Object: ${this.config.tableName}_insert_input!`,
+            `$${alias}OnConflict: ${this.config.tableName}_on_conflict!`
+        ];
+        const queryPart = `${alias}: ${operationName}( objects: [$${alias}Object] on_conflict: $${alias}OnConflict) { affected_rows returning { ${returningColumns.join(', ')} } }`;
+        const variables = { [`${alias}Object`]: object, [`${alias}OnConflict`]: onConflict };
+        return { queryPart, variableDefinitions, variables, operationName, alias };
+    }
+    buildMany(entities, { operationName = `insert_${this.config.tableName}`, constraint = this.config.pk, columns = this.config.columns, returningColumns = this.config.columns, alias = 'save' } = {}) {
+        const objects = this.buildObjects(entities);
+        const onConflict = this.buildOnConflict(entities[0], constraint, columns);
+        const variableDefinitions = [
+            `$${alias}Objects: [${this.config.tableName}_insert_input!]!`,
+            `$${alias}OnConflict: ${this.config.tableName}_on_conflict!`
+        ];
+        const queryPart = `${alias}: ${operationName}(objects: $${alias}Objects on_conflict: $${alias}OnConflict) {
+      affected_rows returning { ${returningColumns.join(', ')} }
+    }`;
+        const variables = { [`${alias}Objects`]: objects, [`${alias}OnConflict`]: onConflict };
+        return { queryPart, variableDefinitions, variables, operationName: operationName, alias };
+    }
+    buildObject(item) {
+        const fields = Object.keys(item).map(snakeCase).filter((field) => !['created_at', 'updated_at'].includes(field));
+        const picked = pick(item, [...fields]);
+        return omitBy(picked, (value) => typeof value === 'undefined');
+    }
+    buildObjects(items) {
+        return items.map((item) => this.buildObject(item));
+    }
+    buildOnConflict(data, constraint, columns) {
+        const fields = Object.keys(this.buildObject(data));
+        const updateColumns = fields.filter(column => columns.includes(column));
+        return { constraint, update_columns: updateColumns };
+    }
+}
+
+class UpdateMutationBuilder {
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    build(data, alias = 'update') {
+        const mutationName = `update_${this.config.tableName}`;
+        const object = this.buildObject(data);
+        const variableDefinitions = [`$${alias}Id: String!`, `$${alias}Object: ${this.config.tableName}_set_input!`];
+        const queryPart = `${alias}: ${mutationName}(where: {id: {_eq: $${alias}Id}} _set: $${alias}Object) { affected_rows returning { id } }`;
+        const variables = { [`${alias}Id`]: data.id, [`${alias}Object`]: object };
+        return { queryPart, variableDefinitions, variables, operationName: mutationName, alias };
+    }
+    buildMany(data, alias = 'updateMany') {
+        const mutationName = `update_${this.config.tableName}_many`;
+        const objects = this.buildObjects(data);
+        const variableDefinitions = [`$${alias}Object: [${this.config.tableName}_updates!]!`];
+        const queryPart = `${alias}: ${mutationName}(updates: $${alias}Objects) { affected_rows returning { id } }`;
+        const variables = { [`${alias}Objects`]: objects };
+        return { queryPart, variableDefinitions, variables, operationName: mutationName, alias };
+    }
+    buildObject(item) {
+        const fields = Object.keys(item).map(snakeCase).filter((field) => !['created_at', 'updated_at'].includes(field));
+        const picked = pick(item, fields);
+        return omitBy(picked, (value) => typeof value === 'undefined');
+    }
+    buildObjects(items) {
+        return items.map((item) => ({ where: { id: { _eq: item.id } }, _set: this.buildObject(item) }));
+    }
+}
+
+class HasuraMutationBuilder {
+    create;
+    update;
+    save;
+    delete_;
+    constructor(config) {
+        this.create = new CreateMutationBuilder(config);
+        this.update = new UpdateMutationBuilder(config);
+        this.save = new SaveMutationBuilder(config);
+        this.delete_ = new DeleteMutationBuilder(config);
+    }
+}
+
+class HasuraQueryPartsBuilder {
+    mutations;
+    queries;
+    constructor(config) {
+        this.mutations = new HasuraMutationBuilder(config);
+        this.queries = new QueriesBuilder(config);
+    }
+}
+
+class HasuraQueryBuilder {
+    parts;
+    constructor(config) {
+        this.parts = new HasuraQueryPartsBuilder(config);
+    }
+    buildQuery(part) {
+        const operationNameStr = part.operationName ? `${part.operationName} ` : '';
+        const variablesStr = part.variableDefinitions?.length ? `(${part.variableDefinitions.join(', ')}) ` : '';
+        return `query ${operationNameStr}${variablesStr}{ ${part.queryPart} }`;
+    }
+    static buildMutation(part) {
+        return `mutation ${part.operationName}(${part.variableDefinitions.join(', ')}) { ${part.queryPart} }`;
+    }
+    buildMutation(part) {
+        return HasuraQueryBuilder.buildMutation(part);
+    }
+    buildTransactionQuery(parts) {
+        const operationName = `Transaction`;
+        const variableDefinitions = parts.reduce((acc, m) => [...acc, ...m.variableDefinitions], []);
+        const mutationParts = parts.map(m => m.queryPart);
+        const query = `mutation ${operationName} (${variableDefinitions.join(', ')}) { ${mutationParts.join('\n')} }`;
+        const variables = parts.reduce((acc, m) => ({ ...acc, ...m.variables }), {});
+        return { query, variables };
+    }
+}
+
 class HasuraService {
     http = inject(HttpClient);
     apollo = inject(Apollo);
@@ -293,18 +565,51 @@ class HasuraService {
             return of(clientOrObsOrPromise);
         }
     }
+    /** @deprecated */
     graphql(args) {
         return this.post('/v1/graphql', {
             query: args.query,
             variables: args.variables,
         });
     }
+    /** @deprecated */
     post(endpoint, body) {
         return this.http.post(`${this.config.url}${endpoint}`, body, {});
     }
+    /** @deprecated */
     delete(endpoint) {
         return this.http.delete(`${this.config.url}${endpoint}`);
     }
+    subscribe({ query, variables }) {
+        return this.getApolloClient().pipe(switchMap((client) => client.subscribe({
+            query: makeSubscription(query),
+            variables: variables,
+            fetchPolicy: 'network-only'
+        })));
+    }
+    async mutate(...args) {
+        const client = await lastValueFrom(this.getApolloClient());
+        return client.mutate(...args).catch((error) => {
+            console.error(error.graphQLErrors);
+            throw error;
+        });
+    }
+    async mutateByQueryPart(part) {
+        return this.mutate({
+            mutation: gql `${HasuraQueryBuilder.buildMutation(part)}`,
+            variables: part.variables,
+        }).then((res) => {
+            console.debug('[HasuraService] mutateByQueryPart:', res);
+            return res.data[part?.alias ?? part.operationName];
+        });
+    }
+    async query(...args) {
+        const client = await lastValueFrom(this.getApolloClient());
+        return client.query(...args).catch((error) => {
+            console.error(error.graphQLErrors);
+            throw error;
+        });
+    }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.1.4", ngImport: i0, type: HasuraService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
     static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.1.4", ngImport: i0, type: HasuraService, providedIn: 'root' });
 }
@@ -313,231 +618,81 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.1.4", ngImpor
             args: [{ providedIn: 'root' }]
         }] });
 
-function makeSubscription(query) {
-    const { kind, definitions } = query;
-    const subscriptionDefinitions = definitions.map((definition) => {
-        if (definition.kind === 'OperationDefinition' && definition.operation === 'query') {
-            return {
-                ...definition,
-                operation: 'subscription',
-            };
-        }
-        return definition;
-    });
-    return { kind, definitions: subscriptionDefinitions };
-}
-;
-class HasuraRepository {
+class HasuraRepository extends Repository {
     hasura = inject(HasuraService);
-    subscribe({ query, variables }) {
-        return this.hasura.getApolloClient().pipe(switchMap((client) => client.subscribe({
-            query: makeSubscription(query),
-            variables: variables,
-        })));
-    }
     get pkey() {
         return `${this.tableName}_pkey`;
     }
+    getQueryBuilder() {
+        return new HasuraQueryBuilder({ tableName: this.tableName, pk: this.pkey, columns: this.updateColumns });
+    }
     async get(params) {
-        const queryName = `${this.tableName}_by_pk`;
-        return lastValueFrom(this.hasura.getApolloClient()).then((client) => client.query({
-            query: gql `query get($id: String!) {
-        ${queryName}(id: $id) {
-          ${this.updateColumns.join(' ')}
-        }
-      }`,
-            variables: params,
-        })).then((res => res.data[queryName])).then(data => data ? this.converter.fromHasura(data) : data);
-    }
-    get listQuery() {
-        return `query list {
-      ${this.tableName} {
-        ${this.updateColumns.join(' ')}
-      }
-    }`;
+        const part = this.getQueryBuilder().parts.queries.get.build({ id: params.id });
+        return this.hasura.query({
+            query: gql$1 `${this.getQueryBuilder().buildQuery(part)}`,
+            variables: part.variables,
+            fetchPolicy: 'network-only',
+        })
+            .then((res) => this.converter.fromHasura(res.data[part.operationName]))
+            .then(data => data ? this.converter.fromHasura(data) : data);
     }
     async list() {
-        const client = await lastValueFrom(this.hasura.getApolloClient());
-        return client.query({
-            query: gql `${this.listQuery}`,
-        }).then(res => this.converter.fromHasuraMany(res.data[this.tableName]));
+        const part = this.getQueryBuilder().parts.queries.get.buildMany();
+        return this.hasura.query({
+            query: gql$1 `${this.getQueryBuilder().buildQuery(part)}`,
+            fetchPolicy: 'network-only'
+        }).then(res => this.converter.fromHasuraMany(res.data[part.operationName]));
     }
     listChanges() {
-        return this.subscribe({
-            query: gql `${this.listQuery}`,
-            variables: {},
-        }).pipe(map(res => this.converter.fromHasuraMany(res.data[this.tableName])));
+        const part = this.getQueryBuilder().parts.queries.get.buildMany();
+        const query = this.getQueryBuilder().buildQuery(part);
+        return this.hasura.subscribe({ query: gql$1 `${query}`, variables: {} }).pipe(map(res => this.converter.fromHasuraMany(res.data[part.operationName])));
     }
     async create(data) {
-        const mutationName = `insert_${this.tableName}`;
-        const mutation = gql `mutation create($object: ${this.tableName}_insert_input!) {
-      ${mutationName}(objects: [$object]) {
-        affected_rows
-        returning {
-          ${this.updateColumns.join(' ')}
-        }
-      }
-    }`;
-        const object = omitBy(omit(this.converter.toHasura(data), ['createdAt', 'updatedAt', 'created_at', 'updated_at']), value => typeof value === 'undefined');
-        const client = await lastValueFrom(this.hasura.getApolloClient());
-        return client.mutate({
-            mutation,
-            variables: { object },
-        }).then(result => {
-            return this.converter.fromHasura(result.data[mutationName].returning[0]);
-        }).catch(error => {
-            console.error(error.graphQLErrors);
-            throw error;
-        });
+        const converted = this.converter.toHasura(data);
+        const part = this.getQueryBuilder().parts.mutations.create.build(converted);
+        return this.hasura.mutateByQueryPart(part).then(result => this.converter.fromHasura(result.returning[0]));
     }
     async createMany(data) {
-        const mutationName = `insert_${this.tableName}`;
-        const objects = data.map((item) => this.converter.toHasura(item));
-        const mutation = gql `
-      mutation createMany($objects: [${this.tableName}_insert_input!]!) {
-        ${mutationName}(objects: $objects) {
-          returning {
-            ${this.updateColumns.join(" ")}
-          }
-        }
-      }
-    `;
-        const client = await lastValueFrom(this.hasura.getApolloClient());
-        return client.mutate({
-            mutation,
-            variables: { objects },
-        }).then((result) => this.converter.fromHasuraMany(result.data[mutationName].returning)).catch((error) => {
-            console.error(error.graphQLErrors);
-            throw error;
-        });
+        const items = this.converter.toHasuraMany(data);
+        const part = this.getQueryBuilder().parts.mutations.create.buildMany(items);
+        return this.hasura.mutateByQueryPart(part).then((result) => this.converter.fromHasuraMany(result.returning));
     }
     async update(data) {
-        const mutation = gql `mutation update($id: String!, $object: ${this.tableName}_set_input!) {
-      update_${this.tableName}(where: {id: {_eq: $id}}, _set: $object) { affected_rows }
-    }`;
-        const fields = Object.keys(data).map(snakeCase);
-        const object = omitBy(omit(pick(this.converter.toHasura(data), fields), ['createdAt', 'updatedAt', 'created_at', 'updated_at']), value => typeof value === 'undefined');
-        const client = await lastValueFrom(this.hasura.getApolloClient());
-        console.debug('[Hasura Repository] update:', object);
-        return client.mutate({
-            mutation,
-            variables: {
-                id: data.id,
-                object,
-            },
-        }).catch(error => {
-            console.error(error.graphQLErrors);
-            throw error;
-        });
+        console.debug('data:', data);
+        const item = this.converter.toHasura(data);
+        console.debug('item:', item);
+        const part = this.getQueryBuilder().parts.mutations.update.build(item);
+        return this.hasura.mutateByQueryPart(part).then(() => { });
     }
     async updateMany(data) {
-        const mutationName = `update_${this.tableName}_many`;
-        const objects = data.map((item) => {
-            const fields = Object.keys(item).map(snakeCase);
-            const object = pick(this.converter.toHasura(item), fields);
-            return { where: { id: { _eq: item.id } }, _set: object };
-        });
-        const mutation = gql `
-      mutation ${mutationName}($objects: [${this.tableName}_updates!]!) {
-        ${mutationName}(updates: $objects) {
-          affected_rows
-        }
-      }
-    `;
-        const client = await lastValueFrom(this.hasura.getApolloClient());
-        return client
-            .mutate({ mutation, variables: { objects } })
-            .then((result) => result.data[mutationName].affected_rows)
-            .catch((error) => {
-            console.error(error.graphQLErrors);
-            throw error;
-        });
-    }
-    async delete(id) {
-        const client = await lastValueFrom(this.hasura.getApolloClient());
-        return client.mutate({
-            mutation: gql `mutation delete($id: String!) {
-        delete_${this.tableName}(where: {id: {_eq: $id}}) { affected_rows }
-      }`,
-            variables: { id },
-        }).catch(error => {
-            console.error(error.graphQLErrors);
-            throw error;
-        });
-    }
-    async save(data) {
-        const object = omit(this.converter.toHasura(data), ['createdAt', 'updatedAt']);
-        const query = gql `mutation upsert($object: [${this.tableName}_insert_input!]!) {
-      insert_${this.tableName}(
-        objects: $object,
-        on_conflict: {
-          constraint: ${this.pkey},
-          update_columns: [${this.updateColumns}]
-        }
-      ) { affected_rows }
-    }`;
-        const client = await lastValueFrom(this.hasura.getApolloClient());
-        console.debug('[Hasura Repository] save:', client);
-        return client.mutate({
-            mutation: query,
-            variables: {
-                object: object,
-            },
-        }).catch(error => {
-            console.error(error.graphQLErrors);
-            throw error;
-        });
+        const items = this.converter.toHasuraMany(data);
+        const part = this.getQueryBuilder().parts.mutations.update.buildMany(items);
+        return this.hasura.mutateByQueryPart(part).then((result) => result.affected_rows).then(() => { });
     }
-    async saveMany(entities) {
-        const query = gql `mutation upsert($objects: [${this.tableName}_insert_input!]!) {
-      insert_${this.tableName}(
-        objects: $objects,
-        on_conflict: {
-          constraint: ${this.pkey},
-          update_columns: [${this.updateColumns}]
-        }
-      ) { affected_rows }
-    }`;
-        const objects = entities.map(entity => this.converter.toHasura(entity));
-        console.debug('[Hasura Repository] objects:', objects);
-        const client = await lastValueFrom(this.hasura.getApolloClient());
-        return client.mutate({
-            mutation: query,
-            variables: { objects },
-        }).catch(error => {
-            console.error(error);
-            // console.error(error.graphQLErrors?.[0]?.extensions?.internal);
-            throw error;
-        });
+    async delete(params) {
+        const part = this.getQueryBuilder().parts.mutations.delete_.build(params);
+        return this.hasura.mutateByQueryPart(part).then(() => { });
     }
     async deleteMany(params) {
-        const mutationName = `delete_${this.tableName}`;
-        const mutation = gql `
-      mutation deleteMany($ids: [String!]!) {
-        ${mutationName}(where: {id: {_in: $ids}}) {
-          affected_rows
-        }
-      }
-    `;
-        const client = await lastValueFrom(this.hasura.getApolloClient());
-        return client.mutate({
-            mutation,
-            variables: { ids: params.map(param => param.id) },
-        }).then((result) => result.data[mutationName].affected_rows).catch((error) => {
-            console.error(error.graphQLErrors);
-            throw error;
-        });
+        const part = this.getQueryBuilder().parts.mutations.delete_.buildMany(params);
+        return this.hasura.mutateByQueryPart(part).then((result) => result.affected_rows);
     }
     async deleteAll() {
-        const client = await lastValueFrom(this.hasura.getApolloClient());
-        return client.mutate({
-            mutation: gql `mutation delete_all {
-        delete_${this.tableName} (where: {}) { affected_rows }
-      }`,
-            variables: {},
-        });
+        const part = this.getQueryBuilder().parts.mutations.delete_.buildAll();
+        return this.hasura.mutateByQueryPart(part).then(() => { });
+    }
+    async save(data) {
+        const item = this.converter.toHasura(data);
+        const part = this.getQueryBuilder().parts.mutations.save.build(item);
+        return this.hasura.mutateByQueryPart(part).then((res) => res.returning[0]);
+    }
+    async saveMany(entities) {
+        const items = this.converter.toHasuraMany(entities);
+        const part = this.getQueryBuilder().parts.mutations.save.buildMany(items);
+        return this.hasura.mutateByQueryPart(part).then(() => { });
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.1.4", ngImport: i0, type: HasuraRepository, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.1.4", ngImport: i0, type: HasuraRepository, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
     static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.1.4", ngImport: i0, type: HasuraRepository });
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.1.4", ngImport: i0, type: HasuraRepository, decorators: [{
@@ -548,5 +703,5 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.1.4", ngImpor
  * Generated bundle index. Do not edit.
  */
 
-export { ApolloMultiService, GET_APOLLO_CLIENT, HASURA_CONFIG, Hasura, HasuraInterceptor, HasuraRepository, HasuraService, HasuraUtils, deepCamelToSnakeCase, deepSnakeToCamelCase, fromHasura, getConverter, getFields, getFlattenFieldAnnotations, makeConverter, makeSubscription, provideApolloOptions, provideGraphqlHeaders, provideHasura, provideHasuraAuthorization, provideHasuraConfig, provideHasuraWithWebSocket, provideHttpLink, provideWebsocketLink, toHasura };
+export { ApolloMultiService, GET_APOLLO_CLIENT, HASURA_CONFIG, Hasura, HasuraInterceptor, HasuraQueryBuilder, HasuraRepository, HasuraService, HasuraUtils, deepCamelToSnakeCase, deepSnakeToCamelCase, fromHasura, getConverter, getFields, getFlattenFieldAnnotations, makeConverter, provideApolloOptions, provideGraphqlHeaders, provideHasura, provideHasuraAuthorization, provideHasuraConfig, provideHasuraWithWebSocket, provideHttpLink, provideWebsocketLink, toHasura };
 //# sourceMappingURL=nx-ddd-hasura.mjs.map