@nx-ddd/hasura 19.0.0-preview.29 → 19.0.0-preview.5

package/fesm2022/nx-ddd-hasura.mjs

@@ -1,707 +0,0 @@
-import * as i0 from '@angular/core';
-import { inject, Injectable, InjectionToken, importProvidersFrom } from '@angular/core';
-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 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, 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';
-
-function wrap(token) {
-    return isObservable(token) ? token : token instanceof Promise ? from(token) : of(token);
-}
-function resolve(getHeaders) {
-    const headers$ = wrap(getHeaders());
-    return lastValueFrom(headers$.pipe(filter((headers) => !!headers), take(1), distinctUntilChanged(), tap((headers) => console.debug('[resolve] headers:', headers))));
-}
-function buildWebsocketLink(endpoint, getHeaders) {
-    return new WebSocketLink({
-        uri: endpoint.replace('http', 'ws'),
-        options: {
-            reconnect: true,
-            connectionParams: () => resolve(getHeaders).then((headers) => ({ headers })),
-        },
-    });
-}
-
-function isSubscription(query) {
-    const definition = getMainDefinition(query);
-    return (definition.kind === 'OperationDefinition' &&
-        definition.operation === 'subscription');
-}
-class ApolloMultiService {
-    apollo = inject(Apollo);
-    httpLink = inject(HttpLink);
-    createClient(name, baseUrl, getHeaders) {
-        const wsLink = buildWebsocketLink(baseUrl, getHeaders);
-        const link = split(({ query }) => isSubscription(query), wsLink, ApolloLink.from([
-            setContext(async () => {
-                const headers = await resolve(getHeaders);
-                return { headers };
-            }),
-            this.httpLink.create({ uri: baseUrl, }),
-        ]));
-        this.apollo.removeClient(name);
-        this.apollo.createNamed(name, { link, cache: new InMemoryCache() });
-    }
-    getClient(endpoint, getHeaders) {
-        const name = endpoint;
-        let client = this.apollo.use(name);
-        console.debug('[ApolloMultiService] getClient:', name);
-        if (!client) {
-            this.createClient(name, endpoint, getHeaders);
-            client = this.apollo.use(name);
-        }
-        return client;
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.1.4", ngImport: i0, type: ApolloMultiService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.1.4", ngImport: i0, type: ApolloMultiService, providedIn: 'root' });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.1.4", ngImport: i0, type: ApolloMultiService, decorators: [{
-            type: Injectable,
-            args: [{ providedIn: 'root' }]
-        }] });
-const GET_APOLLO_CLIENT = makeDI('GET_APOLLO_CLIENT');
-
-const { createDecorator, getAnnotations, } = makeDecoratorFactories((type, fieldName, propName, options) => ({ type, fieldName, propName, childType: options.childType }), '[@nx-ddd/hasura] annotations');
-function getFlattenFieldAnnotations(T, prefix = '') {
-    const annotations = Hasura.getAnnotations(T);
-    return (annotations ?? []).reduce((acc, annotation) => {
-        const currentKey = prefix ? camelCase$1(`${prefix}_${annotation.fieldName}`) : annotation.fieldName;
-        if (annotation.childType) {
-            return {
-                ...acc,
-                ...getFlattenFieldAnnotations(annotation.childType(), currentKey)
-            };
-        }
-        return {
-            ...acc,
-            [currentKey]: annotation
-        };
-    }, {});
-}
-function getFields(T, options = {
-    prefix: '',
-    case: 'snake'
-}) {
-    const annotations = Hasura.getAnnotations(T);
-    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) {
-            return [
-                ...getFields(annotation.childType(), {
-                    prefix: currentKey,
-                    case: options?.case,
-                })
-            ];
-        }
-        return [currentKey];
-    });
-    return fields;
-}
-const Hasura = {
-    Text: createDecorator('text'),
-    Timestamp: createDecorator('timestamp'),
-    Date: createDecorator('date'),
-    Integer: createDecorator('integer'),
-    Numeric: createDecorator('numeric'),
-    Boolean: createDecorator('boolean'),
-    Map: (childType) => createDecorator('map', { childType })(),
-    JSON: createDecorator('json'),
-    getAnnotations,
-};
-
-class HasuraInterceptor {
-    config = inject(HASURA_CONFIG);
-    intercept(req, next) {
-        if (req.url.startsWith(this.config.url)) {
-            return next.handle(req.clone({
-                headers: req.headers.set('x-hasura-admin-secret', this.config.adminSecret),
-            }));
-        }
-        return next.handle(req);
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.1.4", ngImport: i0, type: HasuraInterceptor, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.1.4", ngImport: i0, type: HasuraInterceptor });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.1.4", ngImport: i0, type: HasuraInterceptor, decorators: [{
-            type: Injectable
-        }] });
-
-const HASURA_CONFIG = new InjectionToken('HASURA_CONFIG');
-function provideHasuraConfig(config) {
-    return [
-        { provide: HASURA_CONFIG, useValue: config },
-        config.adminSecret ? { provide: HTTP_INTERCEPTORS, useClass: HasuraInterceptor, multi: true } : [],
-    ];
-}
-
-function deepCamelToSnakeCase(obj) {
-    if (Array.isArray(obj))
-        return obj.map(deepCamelToSnakeCase);
-    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))
-        return obj.map(deepSnakeToCamelCase);
-    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;
-}
-function fromHasura(_object, type) {
-    return HasuraUtils.fromHasura(_object, type);
-}
-function toHasura(object, type, { extraFunc = deepCamelToSnakeCase } = {}) {
-    return HasuraUtils.toHasura(object, type, { extraFunc });
-}
-function getConverter(type) {
-    return {
-        toHasura(entity) {
-            return toHasura(entity, type);
-        },
-        toHasuraMany(entities) {
-            return entities.map((entity) => this.toHasura(entity));
-        },
-        fromHasura(entity) {
-            return fromHasura(entity, type);
-        },
-        fromHasuraMany(entities) {
-            return entities.map((entity) => this.fromHasura(entity));
-        },
-    };
-}
-/** @deprecated use `getConverter` instead */
-const makeConverter = getConverter;
-class HasuraUtils {
-    static toTimestamp(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;
-        }
-    }
-    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 '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 };
-            }
-        }, {});
-        return extraFunc(obj);
-    }
-}
-
-function provideHttpLink() {
-    return {
-        provide: ApolloLink,
-        useFactory: (config) => new HttpLink$1({
-            uri: config.url,
-            headers: config?.adminSecret && { 'x-hasura-admin-secret': config.adminSecret },
-        }),
-        deps: [HASURA_CONFIG],
-    };
-}
-const HASURA_AUTHORIZATION = new InjectionToken('HASURA_AUTHORIZATION');
-function provideHasuraAuthorization(useFactory) {
-    return {
-        provide: HASURA_AUTHORIZATION,
-        useFactory,
-    };
-}
-const GRAPHQL_HEADERS = new InjectionToken('GRAPHQL_HEADERS', {
-    providedIn: 'root',
-    factory: () => () => ({}),
-});
-function provideGraphqlHeaders(useFactory) {
-    return [
-        { provide: GRAPHQL_HEADERS, useFactory },
-    ];
-}
-function provideWebsocketLink() {
-    return {
-        provide: ApolloLink,
-        useFactory: () => {
-            const config = inject(HASURA_CONFIG);
-            const _getHeaders = inject(GRAPHQL_HEADERS);
-            return buildWebsocketLink(config.url, _getHeaders);
-        },
-    };
-}
-function provideApolloOptions() {
-    return {
-        provide: APOLLO_OPTIONS,
-        useFactory: (link) => ({ cache: new InMemoryCache$1(), link }),
-        deps: [ApolloLink],
-    };
-}
-function provideHasura(config) {
-    return [
-        importProvidersFrom(ApolloModule),
-        provideHasuraConfig(config),
-        provideApolloOptions(),
-        provideHttpLink(),
-    ];
-}
-function provideHasuraWithWebSocket(config) {
-    return [
-        importProvidersFrom(ApolloModule),
-        provideHasuraConfig(config),
-        provideApolloOptions(),
-        provideWebsocketLink(),
-    ];
-}
-
-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);
-    config = inject(HASURA_CONFIG);
-    apolloMulti = inject(ApolloMultiService);
-    _getApolloClient = GET_APOLLO_CLIENT.inject() ?? (() => this.apollo.client);
-    getApolloClient() {
-        const clientOrObsOrPromise = this._getApolloClient(this.config);
-        if (isObservable(clientOrObsOrPromise)) {
-            return clientOrObsOrPromise;
-        }
-        else if (clientOrObsOrPromise instanceof Promise) {
-            return from(clientOrObsOrPromise);
-        }
-        else {
-            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' });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.1.4", ngImport: i0, type: HasuraService, decorators: [{
-            type: Injectable,
-            args: [{ providedIn: 'root' }]
-        }] });
-
-class HasuraRepository extends Repository {
-    hasura = inject(HasuraService);
-    get pkey() {
-        return `${this.tableName}_pkey`;
-    }
-    getQueryBuilder() {
-        return new HasuraQueryBuilder({ tableName: this.tableName, pk: this.pkey, columns: this.updateColumns });
-    }
-    async get(params) {
-        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 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() {
-        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 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 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) {
-        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 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 delete(params) {
-        const part = this.getQueryBuilder().parts.mutations.delete_.build(params);
-        return this.hasura.mutateByQueryPart(part).then(() => { });
-    }
-    async deleteMany(params) {
-        const part = this.getQueryBuilder().parts.mutations.delete_.buildMany(params);
-        return this.hasura.mutateByQueryPart(part).then((result) => result.affected_rows);
-    }
-    async deleteAll() {
-        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: 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: [{
-            type: Injectable
-        }] });
-
-/**
- * Generated bundle index. Do not edit.
- */
-
-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