@nx-ddd/hasura 19.0.0-preview-enable-npm-publish.3

package/index.d.ts

@@ -0,0 +1,391 @@
+import * as _nx_ddd_core from '@nx-ddd/core';
+import { ApolloClient, ApolloLink, InMemoryCache, OperationVariables, FetchPolicy, FetchResult, ApolloQueryResult } from '@apollo/client/core';
+import { ApolloLinkService as ApolloLinkService$1, GetHeaders as GetHeaders$1 } from '@nx-ddd/hasura/apollo/link';
+import * as apollo_angular from 'apollo-angular';
+import { Apollo, ApolloBase } from 'apollo-angular';
+import { Observable } from 'rxjs';
+import * as i0 from '@angular/core';
+import { InjectionToken, Provider, EnvironmentProviders } from '@angular/core';
+import { HttpLink } from 'apollo-angular/http';
+import { Type, Repository } from '@nx-ddd/common/domain';
+export { DeepPartial, TransformToDayjs } from '@nx-ddd/common/domain';
+import dayjs from 'dayjs';
+import { HttpInterceptor, HttpRequest, HttpHandler, HttpEvent } from '@angular/common/http';
+import * as _nx_ddd_hasura from '@nx-ddd/hasura';
+import * as lodash from 'lodash';
+export { IsDayjs } from 'class-validator-extended';
+
+interface HasuraConfig {
+    adminSecret?: string;
+    url: string;
+}
+declare const HASURA_CONFIG: InjectionToken<HasuraConfig>;
+declare function provideHasuraConfig(config: HasuraConfig): Provider[];
+
+/** @deprecated use ApolloClientManagerService instead */
+declare class ApolloMultiService {
+    readonly apollo: Apollo;
+    protected readonly linkService: ApolloLinkService$1;
+    protected createClient(name: string, baseUrl: string, getHeaders: GetHeaders$1): void;
+    getClient(endpoint: string, getHeaders: GetHeaders$1): ApolloBase;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ApolloMultiService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ApolloMultiService>;
+}
+type GetApolloClient<E extends {
+    id: string;
+}> = (config: HasuraConfig) => ApolloClient | Promise<ApolloClient> | Observable<ApolloClient>;
+declare const GET_APOLLO_CLIENT: _nx_ddd_core.DiToken<GetApolloClient<any>>;
+
+type PromiseOrObservable$1<T> = Promise<T> | Observable<T> | T;
+type GetHeaders = () => PromiseOrObservable$1<Record<string, string>>;
+declare function wrap<T>(obsOrPromiseOrValue: Promise<T> | Observable<T> | T): Observable<T>;
+declare function resolve(getHeaders: GetHeaders): Promise<Record<string, string>>;
+
+declare class ApolloLinkService {
+    readonly httpLink: HttpLink;
+    readonly WebSocketImpl: {
+        new (url: string | URL, protocols?: string | string[]): WebSocket;
+        prototype: WebSocket;
+        readonly CONNECTING: 0;
+        readonly OPEN: 1;
+        readonly CLOSING: 2;
+        readonly CLOSED: 3;
+    };
+    private createGraphQLWsClient;
+    createHttpLink(baseUrl: string, getHeaders: GetHeaders): ApolloLink;
+    createWebSocketLink(baseUrl: string, getHeaders: GetHeaders): ApolloLink;
+    createAutoSplitLink(baseUrl: string, getHeaders: GetHeaders): ApolloLink;
+    createLink(baseUrl: string, getHeaders: GetHeaders): ApolloLink;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ApolloLinkService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ApolloLinkService>;
+}
+
+declare class ApolloClientManagerService {
+    readonly apollo: Apollo;
+    protected readonly linkService: ApolloLinkService;
+    protected readonly crypto: webcrypto.Crypto;
+    protected buildClientName(endpoint: string, headers: Record<string, string>): Promise<string>;
+    getClient(endpoint: string, getHeaders: GetHeaders): Observable<ApolloBase<any>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ApolloClientManagerService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ApolloClientManagerService>;
+}
+
+interface HasuraConverter<E> {
+    toHasura(entity: E): object;
+    toHasuraMany(entities: E[]): object[];
+    fromHasura(entity: object): E;
+    fromHasuraMany(entities: object[]): E[];
+}
+type CamelToSnakeCase<S extends string> = S extends `${infer T}${infer U}` ? U extends Uncapitalize<U> ? `${Lowercase<T>}${CamelToSnakeCase<U>}` : `${Lowercase<T>}_${CamelToSnakeCase<U>}` : S;
+type DeepCamelToSnake<T> = T extends Date ? T : T extends Array<infer U> ? DeepCamelToSnake<U>[] : T extends object ? {
+    [K in keyof T as K extends string ? CamelToSnakeCase<K> : K]: DeepCamelToSnake<T[K]>;
+} : T;
+declare function deepCamelToSnakeCase<T>(obj: T): DeepCamelToSnake<T>;
+type SnakeToCamelCase<S extends string> = S extends `${infer T}_${infer U}` ? `${T}${Capitalize<SnakeToCamelCase<U>>}` : S;
+type DeepSnakeToCamel<T> = T extends Date ? T : T extends Array<infer U> ? DeepSnakeToCamel<U>[] : T extends object ? {
+    [K in keyof T as K extends string ? SnakeToCamelCase<K> : K]: DeepSnakeToCamel<T[K]>;
+} : T;
+declare function deepSnakeToCamelCase<T>(obj: T): DeepSnakeToCamel<T>;
+declare function getConverter<T>(type: Type<T>): HasuraConverter<T>;
+/** @deprecated use `getConverter` instead */
+declare const makeConverter: typeof getConverter;
+declare class HasuraUtils {
+    static toTimestamp(date: dayjs.Dayjs | Date | null): string | null;
+    static toDate(date: dayjs.Dayjs | Date | string | null | undefined): string | null | undefined;
+    static fromHasura<T>(_object: any, type: Type<T>): T;
+    static toNumber(value: any): number | null | undefined;
+    static toHasuraLocation(position: {
+        lat: number;
+        lng: number;
+    } | null | undefined): {
+        type: string;
+        crs: {
+            type: string;
+            properties: {
+                name: string;
+            };
+        };
+        coordinates: number[];
+    };
+    static fromHasuraLocation(location: {
+        type: 'Point';
+        crs: {
+            type: 'name';
+            properties: {
+                name: 'urn:ogc:def:crs:EPSG::4326';
+            };
+        };
+        coordinates: [number, number];
+    }): {
+        lat: number;
+        lng: number;
+    };
+    static toHasura<E>(object: E, type: Type<E>, { extraFunc }?: {
+        extraFunc?: (obj: any) => any;
+    }): any;
+}
+
+declare function getFieldAnnotationMap<Annotation>(T: any, prefix?: string): Record<string, Annotation>;
+declare function getFlattenFieldAnnotations<Annotation>(T: any, prefix?: string): Record<string, Annotation>;
+declare function getFields(T: any, options?: {
+    prefix?: string;
+    case?: 'snake' | 'camel';
+}): string[];
+declare function getTableName(target: any): string;
+declare const Hasura: {
+    Table: (nameOrProps: {
+        name: string;
+    } | string) => (target: any) => void;
+    Text: (nameOrProps?: {
+        name?: string;
+    } | string) => (target: any, propName: string) => void;
+    Timestamp: (nameOrProps?: {
+        name?: string;
+    } | string) => (target: any, propName: string) => void;
+    Date: (nameOrProps?: {
+        name?: string;
+    } | string) => (target: any, propName: string) => void;
+    Integer: (nameOrProps?: {
+        name?: string;
+    } | string) => (target: any, propName: string) => void;
+    Numeric: (nameOrProps?: {
+        name?: string;
+    } | string) => (target: any, propName: string) => void;
+    Boolean: (nameOrProps?: {
+        name?: string;
+    } | string) => (target: any, propName: string) => void;
+    Map: (childType: () => any) => (target: any, propName: string) => void;
+    JSON: (nameOrProps?: {
+        name?: string;
+    } | string) => (target: any, propName: string) => void;
+    Location: (nameOrProps?: {
+        name?: string;
+    } | string) => (target: any, propName: string) => void;
+    getAnnotations: (target: any) => {
+        type: string;
+        fieldName: string;
+        propName: string;
+        childType: any;
+    }[];
+};
+
+type PromiseOrObservable<T> = Promise<T> | Observable<T> | T;
+declare const GRAPHQL_HEADERS: InjectionToken<GetHeaders>;
+declare function provideHasuraGetHeaders(useFactory: () => () => PromiseOrObservable<Record<string, string>>): Provider;
+/**
+ * @deprecated use provideHasuraGetHeaders instead
+ */
+declare const provideGraphqlHeaders: typeof provideHasuraGetHeaders;
+declare function provideApolloOptions(): {
+    provide: InjectionToken<any>;
+    useFactory: (link: ApolloLink) => {
+        cache: InMemoryCache;
+        link: ApolloLink;
+    };
+    deps: (typeof ApolloLink)[];
+};
+declare function provideHasura(config: HasuraConfig): (Provider | EnvironmentProviders)[];
+declare function provideHasuraWithWebSocket(config: HasuraConfig): (Provider | EnvironmentProviders)[];
+
+declare class HasuraInterceptor implements HttpInterceptor {
+    private config;
+    intercept(req: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HasuraInterceptor, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<HasuraInterceptor>;
+}
+
+interface TransactionQueryPart {
+    queryPart: string;
+    variableDefinitions: string[];
+    variables: Record<string, any>;
+    operationName: string;
+    alias?: string;
+}
+interface TableConfig {
+    tableName: string;
+    columns: string[];
+    pk: string;
+}
+
+type CreateData<E> = Omit<E, 'id' | 'createdAt' | 'updatedAt'>;
+declare class CreateMutationBuilder<E extends {
+    id: string;
+}> {
+    protected readonly config: TableConfig;
+    constructor(config: TableConfig);
+    build(data: CreateData<E>, alias?: string): TransactionQueryPart;
+    buildMany(data: CreateData<E>[], alias?: string): TransactionQueryPart;
+    protected convertToObject(item: CreateData<E>): lodash.Dictionary<unknown>;
+    protected convertToObjects(items: CreateData<E>[]): lodash.Dictionary<unknown>[];
+}
+
+declare class DeleteMutationBuilder {
+    protected readonly config: TableConfig;
+    constructor(config: TableConfig);
+    build({ id }: {
+        id: any;
+    }): TransactionQueryPart;
+    buildMany(params: {
+        id: string;
+    }[], alias?: string): TransactionQueryPart;
+    buildAll(alias?: string): TransactionQueryPart;
+}
+
+interface Options {
+    operationName?: string;
+    constraint?: string;
+    columns?: string[];
+    returningColumns?: string[];
+    alias?: string;
+}
+declare class SaveMutationBuilder<E = any> {
+    protected readonly config: TableConfig;
+    constructor(config: TableConfig);
+    build(data: Omit<E, 'createdAt' | 'updatedAt'>, { operationName, constraint, columns, returningColumns, alias, }?: Options): TransactionQueryPart;
+    buildMany(entities: E[], { operationName, constraint, columns, returningColumns, alias }?: Options): TransactionQueryPart;
+    protected buildObject(item: Omit<E, 'createdAt' | 'updatedAt'>): lodash.Dictionary<unknown>;
+    protected buildObjects(items: Omit<E, 'createdAt' | 'updatedAt'>[]): lodash.Dictionary<unknown>[];
+    protected buildOnConflict(data: Omit<E, 'createdAt' | 'updatedAt'>, constraint: string, columns: string[]): {
+        constraint: string;
+        update_columns: string[];
+    };
+}
+
+declare class UpdateMutationBuilder<E extends {
+    id: string;
+} = any> {
+    protected readonly config: TableConfig;
+    constructor(config: TableConfig);
+    build(data: Partial<E> & {
+        id: string;
+    }, alias?: string): TransactionQueryPart;
+    buildMany(data: Partial<E>[], alias?: string): TransactionQueryPart;
+    protected buildObject(item: Partial<E>): any;
+    protected buildObjects(items: Partial<E>[]): any[];
+}
+
+declare class HasuraMutationBuilder<E extends {
+    id: string;
+}> {
+    readonly create: CreateMutationBuilder<E>;
+    readonly update: UpdateMutationBuilder<E>;
+    readonly save: SaveMutationBuilder<E>;
+    readonly delete_: DeleteMutationBuilder;
+    constructor(config: TableConfig);
+}
+
+declare class GetQueryPartBuilder {
+    protected config: TableConfig;
+    constructor(config: TableConfig);
+    build(params: {
+        id: string;
+    }): TransactionQueryPart;
+    buildMany(): TransactionQueryPart;
+}
+
+declare class QueriesBuilder<E extends {
+    id: string;
+}> {
+    readonly get: GetQueryPartBuilder;
+    constructor(config: TableConfig);
+    makeSubscription(query: any): {
+        kind: any;
+        definitions: any;
+    };
+}
+
+declare class HasuraQueryPartsBuilder<E extends {
+    id: string;
+}> {
+    readonly mutations: HasuraMutationBuilder<E>;
+    readonly queries: QueriesBuilder<E>;
+    constructor(config: TableConfig);
+}
+
+declare class HasuraQueryBuilder<E extends {
+    id: string;
+}> {
+    readonly parts: HasuraQueryPartsBuilder<E>;
+    constructor(config: TableConfig);
+    buildQuery(part: TransactionQueryPart): string;
+    static buildMutation(part: TransactionQueryPart): string;
+    buildMutation(part: TransactionQueryPart): string;
+    buildTransactionQuery(parts: TransactionQueryPart[]): {
+        query: string;
+        variables: Record<string, any>;
+    };
+}
+
+declare class HasuraService {
+    protected readonly getHeaders: _nx_ddd_hasura.GetHeaders;
+    protected readonly apolloClientManager: ApolloClientManagerService;
+    protected readonly config: HasuraConfig;
+    getApolloClient(): Observable<ApolloBase<any>>;
+    subscribe<T = any, TVariables extends OperationVariables = OperationVariables>({ query, variables, fetchPolicy, context }: {
+        query: any;
+        variables: TVariables;
+        fetchPolicy?: FetchPolicy;
+        context?: Record<string, unknown>;
+    }): Observable<FetchResult<T>>;
+    mutate<T = any>(...args: Parameters<ApolloBase['mutate']>): Promise<apollo_angular.MutationResult<unknown>>;
+    mutateByQueryPart<T = any>(part: TransactionQueryPart): Promise<T>;
+    query<T = any>(...args: Parameters<ApolloBase['query']>): Promise<ApolloQueryResult<T>>;
+    watchQuery<T = any, TVariables extends OperationVariables = OperationVariables>(options: {
+        query: any;
+        variables?: TVariables;
+        fetchPolicy?: FetchPolicy;
+    }): Observable<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HasuraService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<HasuraService>;
+}
+
+declare abstract class _HasuraRepository<E extends {
+    id: string;
+}> extends Repository<E> {
+    protected abstract hasura: HasuraService;
+    protected abstract converter: HasuraConverter<E>;
+    readonly abstract updateColumns: string[];
+    readonly abstract tableName: string;
+    get pkey(): string;
+    getQueryBuilder(): HasuraQueryBuilder<{
+        id: string;
+    }>;
+    get(params: {
+        id: string;
+    }): Promise<E>;
+    list(): Promise<E[]>;
+    listChanges(): Observable<E[]>;
+    create(data: Omit<E, 'id' | 'createdAt' | 'updatedAt'> & Partial<Pick<E, 'id'>>): Promise<E>;
+    createMany(data: Omit<E, 'id' | 'createdAt' | 'updatedAt'>[]): Promise<E[]>;
+    update(data: Partial<E> & {
+        id: string;
+    }): Promise<void>;
+    updateMany(data: Partial<E>[]): Promise<void>;
+    delete(params: {
+        id: string;
+    }): Promise<void>;
+    deleteMany(params: {
+        id: string;
+    }[]): Promise<number>;
+    deleteAll(): Promise<void>;
+    save(data: Partial<E>): Promise<any>;
+    saveMany(entities: E[]): Promise<void>;
+}
+declare abstract class HasuraRepository<E extends {
+    id: string;
+}> extends _HasuraRepository<E> {
+    protected hasura: HasuraService;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HasuraRepository<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<HasuraRepository<any>>;
+}
+declare function getHasuraRepository<E extends {
+    id: string;
+}>(Entity: Type<E>, deps: {
+    hasura: HasuraService;
+}): _HasuraRepository<E>;
+declare function injectHasuraRepository<E extends {
+    id: string;
+}>(Entity: Type<E>): _HasuraRepository<E>;
+
+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 };
+export type { GetApolloClient, GetHeaders, HasuraConfig, HasuraConverter, TableConfig, TransactionQueryPart };

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@nx-ddd/hasura",
+  "version": "19.0.0-preview-enable-npm-publish.3",
+  "license": "MIT",
+  "peerDependencies": {
+    "@nx-ddd/core": "19.0.0-preview-enable-npm-publish.3"
+  },
+  "dependencies": {
+    "tslib": "^2.3.0"
+  },
+  "module": "fesm2022/nx-ddd-hasura.mjs",
+  "typings": "index.d.ts",
+  "exports": {
+    "./package.json": {
+      "default": "./package.json"
+    },
+    ".": {
+      "types": "./index.d.ts",
+      "default": "./fesm2022/nx-ddd-hasura.mjs"
+    },
+    "./browser": {
+      "types": "./browser/index.d.ts",
+      "default": "./fesm2022/nx-ddd-hasura-browser.mjs"
+    },
+    "./server": {
+      "types": "./server/index.d.ts",
+      "default": "./fesm2022/nx-ddd-hasura-server.mjs"
+    },
+    "./apollo/link": {
+      "types": "./apollo/link/index.d.ts",
+      "default": "./fesm2022/nx-ddd-hasura-apollo-link.mjs"
+    }
+  },
+  "sideEffects": false
+}

package/server/index.d.ts

@@ -0,0 +1,8 @@
+import { Provider } from '@angular/core';
+
+/**
+ * Provides all necessary dependencies for Hasura in Node.js/server environments
+ */
+declare function provideHasuraServer(): Provider[];
+
+export { provideHasuraServer };