@nx-ddd/hasura 19.0.0-preview.9 → 19.1.1

package/fesm2022/nx-ddd-hasura.mjs

@@ -0,0 +1,880 @@
+import * as i0 from '@angular/core';
+import { inject, Injectable, InjectionToken } from '@angular/core';
+import { InMemoryCache } from '@apollo/client/cache';
+import { makeDI, makeDecoratorFactories, plainToInstanceWithValid } from '@nx-ddd/core';
+import { ApolloLinkService as ApolloLinkService$1 } from '@nx-ddd/hasura/apollo/link';
+import { Apollo, APOLLO_OPTIONS, provideApollo, gql } from 'apollo-angular';
+import { HttpLink } from 'apollo-angular/http';
+import { setContext } from '@apollo/client/link/context';
+import { ApolloLink, split, InMemoryCache as InMemoryCache$1, gql as gql$1 } from '@apollo/client/core';
+import { getMainDefinition } from '@apollo/client/utilities';
+import { GraphQLWsLink } from '@apollo/client/link/subscriptions';
+import { createClient } from 'graphql-ws';
+import { isObservable, from, of, lastValueFrom, filter, take, distinctUntilChanged, switchMap, map } from 'rxjs';
+import { WEBSOCKET } from '@nx-ddd/common/infrastructure/externals/websocket/token';
+import { CRYPTO } from '@nx-ddd/common/infrastructure/externals/crypto/token';
+import { camelCase as camelCase$1, snakeCase, get, pick, omitBy } from 'lodash-es';
+import dayjs from 'dayjs';
+import { format, parse } from 'date-fns';
+import { formatInTimeZone } from 'date-fns-tz';
+import { HTTP_INTERCEPTORS } from '@angular/common/http';
+import { Repository } from '@nx-ddd/common/domain';
+export { TransformToDayjs } from '@nx-ddd/common/domain';
+export { IsDayjs } from 'class-validator-extended';
+
+/** @deprecated use ApolloClientManagerService instead */
+class ApolloMultiService {
+    apollo = inject(Apollo);
+    linkService = inject(ApolloLinkService$1);
+    createClient(name, baseUrl, getHeaders) {
+        this.apollo.removeClient(name);
+        this.apollo.createNamed(name, {
+            link: this.linkService.createLink(baseUrl, getHeaders),
+            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: "20.0.5", ngImport: i0, type: ApolloMultiService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.0.5", ngImport: i0, type: ApolloMultiService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.0.5", ngImport: i0, type: ApolloMultiService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+const GET_APOLLO_CLIENT = makeDI('GET_APOLLO_CLIENT');
+
+function wrap(obsOrPromiseOrValue) {
+    if (isObservable(obsOrPromiseOrValue))
+        return obsOrPromiseOrValue;
+    if (obsOrPromiseOrValue instanceof Promise)
+        return from(obsOrPromiseOrValue);
+    return of(obsOrPromiseOrValue);
+}
+function resolve(getHeaders) {
+    const headers$ = wrap(getHeaders());
+    return lastValueFrom(headers$.pipe(filter((headers) => !!headers), take(1), distinctUntilChanged()));
+}
+
+function isSubscription(query) {
+    const definition = getMainDefinition(query);
+    return (definition.kind === 'OperationDefinition' &&
+        definition.operation === 'subscription');
+}
+class ApolloLinkService {
+    httpLink = inject(HttpLink);
+    WebSocketImpl = WEBSOCKET.inject();
+    createGraphQLWsClient(baseUrl, getHeaders) {
+        return createClient({
+            url: baseUrl.replace('http', 'ws'),
+            webSocketImpl: this.WebSocketImpl,
+            connectionParams: async () => {
+                const headers = await resolve(getHeaders);
+                return { headers };
+            },
+            lazy: true, // 必要時のみ接続を開始
+            shouldRetry: () => true, // 再接続を有効化
+            retryAttempts: 5, // 再接続試行回数を制限
+            keepAlive: 30000, // 30秒ごとにキープアライブ
+        });
+    }
+    createHttpLink(baseUrl, getHeaders) {
+        return ApolloLink.from([
+            setContext(async () => {
+                const headers = await resolve(getHeaders);
+                return { headers };
+            }),
+            this.httpLink.create({ uri: baseUrl, }),
+        ]);
+    }
+    createWebSocketLink(baseUrl, getHeaders) {
+        return new GraphQLWsLink(this.createGraphQLWsClient(baseUrl, getHeaders));
+    }
+    createAutoSplitLink(baseUrl, getHeaders) {
+        return split(({ query }) => isSubscription(query), this.createWebSocketLink(baseUrl, getHeaders), this.createHttpLink(baseUrl, getHeaders));
+    }
+    createLink(baseUrl, getHeaders) {
+        return this.createAutoSplitLink(baseUrl, getHeaders);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.0.5", ngImport: i0, type: ApolloLinkService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.0.5", ngImport: i0, type: ApolloLinkService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.0.5", ngImport: i0, type: ApolloLinkService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+class ApolloClientManagerService {
+    apollo = inject(Apollo);
+    linkService = inject(ApolloLinkService);
+    crypto = CRYPTO.inject();
+    async buildClientName(endpoint, headers) {
+        const data = new TextEncoder().encode(JSON.stringify(headers));
+        const arrayBuffer = await this.crypto.subtle.digest('SHA-256', data);
+        const hash = Array.from(new Uint8Array(arrayBuffer)).map(b => b.toString(16).padStart(2, '0')).join('');
+        return `${endpoint}?headers=${hash}`;
+    }
+    getClient(endpoint, getHeaders) {
+        return wrap(getHeaders()).pipe(take(1), switchMap(async (headers) => {
+            const name = await this.buildClientName(endpoint, headers);
+            const client = this.apollo.use(name);
+            if (!client) {
+                this.apollo.removeClient(name);
+                this.apollo.createNamed(name, {
+                    link: this.linkService.createLink(endpoint, getHeaders),
+                    cache: new InMemoryCache()
+                });
+                return this.apollo.use(name);
+            }
+            return client;
+        }));
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.0.5", ngImport: i0, type: ApolloClientManagerService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.0.5", ngImport: i0, type: ApolloClientManagerService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.0.5", ngImport: i0, type: ApolloClientManagerService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+const { createDecorator, 
+// createClassDecorator,
+addAnnotation, getAnnotations, } = makeDecoratorFactories((type, fieldName, propName, options) => ({ type, fieldName, propName, childType: options.childType }), '[@nx-ddd/hasura] annotations');
+function getFieldAnnotationMap(T, prefix = '') {
+    const annotations = Hasura.getAnnotations(T);
+    return (annotations ?? []).reduce((acc, annotation) => {
+        const currentKey = prefix ? camelCase$1(`${prefix}_${annotation.fieldName}`) : annotation.fieldName;
+        return { ...acc, [currentKey]: annotation };
+    }, {});
+}
+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).filter((annotation) => annotation.type !== 'table');
+    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;
+}
+function createClassDecorator(type) {
+    return (nameOrProps) => {
+        const props = typeof nameOrProps === 'string' ? { name: nameOrProps } : nameOrProps;
+        return (target) => {
+            const name = props?.name || target.name;
+            const annotation = { type, name };
+            addAnnotation(target, annotation);
+        };
+    };
+}
+function getTableName(target) {
+    const annotations = getAnnotations(target);
+    const annotation = annotations.find((annotation) => annotation.type === 'table');
+    return annotation.name;
+}
+const Hasura = {
+    Table: createClassDecorator('table'),
+    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'),
+    Location: createDecorator('location'),
+    getAnnotations,
+};
+
+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 getConverter(type) {
+    return {
+        toHasura(entity) {
+            return HasuraUtils.toHasura(entity, type);
+        },
+        toHasuraMany(entities) {
+            return entities.map((entity) => this.toHasura(entity));
+        },
+        fromHasura(entity) {
+            return HasuraUtils.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)) {
+            // Dayjsオブジェクトの場合、既に適切なタイムゾーンで処理されているとみなす
+            return date.format('YYYY-MM-DD');
+        }
+        else if (date instanceof Date) {
+            // formatInTimeZoneを使用してローカルタイムゾーンで処理
+            return formatInTimeZone(date, Intl.DateTimeFormat().resolvedOptions().timeZone, 'yyyy-MM-dd');
+        }
+        else if (typeof date === 'string') {
+            return date;
+        }
+        else {
+            return null;
+        }
+    }
+    static fromHasura(_object, type) {
+        const fieldMap = getFieldAnnotationMap(type);
+        // ネストされたmap型の再帰的復元
+        function extractNestedMap(mapKey, childType, object) {
+            const childFieldMap = getFieldAnnotationMap(childType);
+            const childFields = {};
+            Object.entries(childFieldMap).forEach(([childKey, childAnnotation]) => {
+                if (childAnnotation.type === 'map') {
+                    // 再帰的にネストを復元
+                    const nested = extractNestedMap(`${mapKey}_${childKey}`, childAnnotation.childType(), object);
+                    if (nested && Object.keys(nested).length > 0) {
+                        childFields[childAnnotation.fieldName] = nested;
+                    }
+                }
+                else {
+                    const flattenedKey = `${mapKey}_${childKey}`;
+                    const value = get(object, snakeCase(flattenedKey));
+                    if (typeof value !== 'undefined') {
+                        childFields[childAnnotation.fieldName] = value;
+                    }
+                }
+            });
+            return childFields;
+        }
+        // First extract any flattened map fields (e.g., profile_bio)
+        const nestedObjects = {};
+        Object.entries(fieldMap).forEach(([key, annotation]) => {
+            if (annotation.type === 'map') {
+                const childType = annotation.childType();
+                const nested = extractNestedMap(key, childType, _object);
+                if (nested && Object.keys(nested).length > 0) {
+                    nestedObjects[annotation.fieldName] = nested;
+                }
+            }
+        });
+        // Now process all fields normally
+        const obj = Object.entries(fieldMap).reduce((acc, [key, annotation]) => {
+            // For map types, use our previously extracted nested objects
+            if (annotation.type === 'map') {
+                const nestedObj = nestedObjects[annotation.fieldName];
+                if (nestedObj) {
+                    return { ...acc, [annotation.fieldName]: nestedObj };
+                }
+                return acc;
+            }
+            const value = get(_object, snakeCase(key));
+            if (typeof value === 'undefined')
+                return acc;
+            switch (annotation.type) {
+                case 'text': return { ...acc, [annotation.fieldName]: value };
+                case 'timestamp': return { ...acc, [annotation.fieldName]: value === null ? null : parse(value, 'yyyy-MM-dd HH:mm:ss', new Date()) };
+                case 'date': {
+                    const parsedDate = value === null ? null : parse(value, 'yyyy-MM-dd', new Date());
+                    return { ...acc, [annotation.fieldName]: parsedDate };
+                }
+                case 'numeric': return { ...acc, [annotation.fieldName]: value };
+                case 'integer': return { ...acc, [annotation.fieldName]: value };
+                case 'json': return { ...acc, [annotation.fieldName]: value };
+                case 'location': return { ...acc, [annotation.fieldName]: this.fromHasuraLocation(value) };
+                default: return { ...acc, [annotation.fieldName]: value };
+            }
+        }, {});
+        return plainToInstanceWithValid(type, obj);
+    }
+    static toNumber(value) {
+        if (typeof value === 'undefined')
+            return undefined;
+        if (value === null)
+            return null;
+        if (value === '' || (typeof value === 'string' && value.trim() === ''))
+            return null;
+        return isNaN(Number(value)) ? null : Number(value);
+    }
+    static toHasuraLocation(position) {
+        if (!(position?.lat && position?.lng))
+            return null;
+        return {
+            type: 'Point',
+            crs: {
+                type: 'name',
+                properties: { name: 'urn:ogc:def:crs:EPSG::4326' }
+            },
+            coordinates: [position.lng, position.lat]
+        };
+    }
+    static fromHasuraLocation(location) {
+        if (!location)
+            return null;
+        return {
+            lat: location.coordinates?.[1],
+            lng: location.coordinates?.[0],
+        };
+    }
+    static toHasura(object, type, { extraFunc = deepCamelToSnakeCase } = {}) {
+        const fieldMap = getFieldAnnotationMap(type);
+        const obj = Object.entries(fieldMap).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': {
+                    const childObj = this.toHasura(value, annotation.childType(), { extraFunc });
+                    const flattenedObj = Object.entries(childObj).reduce((childAcc, [childKey, childValue]) => ({
+                        ...childAcc,
+                        [`${key}_${childKey}`]: childValue
+                    }), {});
+                    return { ...acc, ...flattenedObj };
+                }
+                case 'location': return { ...acc, [key]: this.toHasuraLocation(value) };
+                default: return { ...acc, [key]: value };
+            }
+        }, {});
+        return extraFunc(obj);
+    }
+}
+
+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: "20.0.5", ngImport: i0, type: HasuraInterceptor, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.0.5", ngImport: i0, type: HasuraInterceptor });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.0.5", 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 } : [],
+    ];
+}
+
+const GRAPHQL_HEADERS = new InjectionToken('GRAPHQL_HEADERS', {
+    providedIn: 'root',
+    factory: () => () => ({}),
+});
+function provideHasuraGetHeaders(useFactory) {
+    return [
+        { provide: GRAPHQL_HEADERS, useFactory },
+    ];
+}
+/**
+ * @deprecated use provideHasuraGetHeaders instead
+ */
+const provideGraphqlHeaders = provideHasuraGetHeaders;
+function provideApolloOptions() {
+    return {
+        provide: APOLLO_OPTIONS,
+        useFactory: (link) => ({ cache: new InMemoryCache$1(), link }),
+        deps: [ApolloLink],
+    };
+}
+function provideHasura(config) {
+    return [
+        provideApollo(() => ({
+            cache: new InMemoryCache$1(),
+            link: inject(ApolloLink),
+        })),
+        provideHasuraConfig(config),
+    ];
+}
+function provideHasuraWithWebSocket(config) {
+    return [
+        provideApollo(() => ({
+            cache: new InMemoryCache$1(),
+            link: inject(ApolloLink),
+        })),
+        provideHasuraConfig(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}Objects: [${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) {
+        const operationNameStr = part.operationName ? `${part.operationName} ` : '';
+        const variablesStr = part.variableDefinitions?.length ? `(${part.variableDefinitions.join(', ')}) ` : '';
+        return `mutation ${operationNameStr}${variablesStr} { ${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 {
+    getHeaders = inject(GRAPHQL_HEADERS);
+    apolloClientManager = inject(ApolloClientManagerService);
+    config = inject(HASURA_CONFIG);
+    getApolloClient() {
+        return this.apolloClientManager.getClient(this.config.url, this.getHeaders);
+    }
+    subscribe({ query, variables, fetchPolicy = 'network-only', context }) {
+        return this.getApolloClient().pipe(switchMap((client) => client.subscribe({
+            query: makeSubscription(query),
+            variables: variables,
+            fetchPolicy: fetchPolicy,
+            context
+        })));
+    }
+    async mutate(...args) {
+        const client = await lastValueFrom(this.getApolloClient());
+        return lastValueFrom(client.mutate(...args)).catch((error) => {
+            console.error(error.graphQLErrors);
+            throw error;
+        });
+    }
+    async mutateByQueryPart(part) {
+        const mutation = HasuraQueryBuilder.buildMutation(part);
+        return this.mutate({
+            mutation: gql `${mutation}`,
+            variables: part.variables,
+        }).then((res) => {
+            return res.data[part?.alias ?? part.operationName];
+        });
+    }
+    async query(...args) {
+        const client = await lastValueFrom(this.getApolloClient());
+        // fetchPolicyが指定されていない場合はnetwork-onlyをデフォルトに
+        const [options] = args;
+        const queryOptions = {
+            ...options,
+            fetchPolicy: options?.fetchPolicy || 'network-only'
+        };
+        return lastValueFrom(client.query(queryOptions)).catch((error) => {
+            console.error('[HasuraService] query error:', error);
+            throw error;
+        });
+    }
+    // Observable版のqueryメソッド（キャッシュ可能）
+    watchQuery(options) {
+        const { query, variables, fetchPolicy = 'cache-first' } = options;
+        return this.getApolloClient().pipe(switchMap((client) => client.watchQuery({
+            query: makeSubscription(query),
+            variables: variables,
+            fetchPolicy: fetchPolicy
+        }).valueChanges));
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.0.5", ngImport: i0, type: HasuraService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.0.5", ngImport: i0, type: HasuraService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.0.5", ngImport: i0, type: HasuraService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+class _HasuraRepository extends Repository {
+    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]));
+    }
+    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 => {
+            return 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) => {
+            return this.converter.fromHasuraMany(result.returning);
+        });
+    }
+    async update(data) {
+        const item = this.converter.toHasura(data);
+        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();
+        console.debug('part:', part);
+        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(() => { });
+    }
+}
+class HasuraRepository extends _HasuraRepository {
+    hasura = inject(HasuraService);
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.0.5", ngImport: i0, type: HasuraRepository, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.0.5", ngImport: i0, type: HasuraRepository });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.0.5", ngImport: i0, type: HasuraRepository, decorators: [{
+            type: Injectable
+        }] });
+function getHasuraRepository(Entity, deps) {
+    class Repository extends _HasuraRepository {
+        hasura = deps.hasura;
+        converter = getConverter(Entity);
+        tableName = getTableName(Entity);
+        updateColumns = getFields(Entity, { case: 'snake' });
+    }
+    return new Repository();
+}
+function injectHasuraRepository(Entity) {
+    return getHasuraRepository(Entity, { hasura: inject(HasuraService) });
+}
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { ApolloClientManagerService, ApolloMultiService, GET_APOLLO_CLIENT, GRAPHQL_HEADERS, HASURA_CONFIG, Hasura, HasuraInterceptor, HasuraQueryBuilder, HasuraRepository, HasuraService, HasuraUtils, _HasuraRepository, deepCamelToSnakeCase, deepSnakeToCamelCase, getConverter, getFieldAnnotationMap, getFields, getFlattenFieldAnnotations, getHasuraRepository, getTableName, injectHasuraRepository, makeConverter, provideApolloOptions, provideGraphqlHeaders, provideHasura, provideHasuraConfig, provideHasuraGetHeaders, provideHasuraWithWebSocket, resolve, wrap };
+//# sourceMappingURL=nx-ddd-hasura.mjs.map