@infrab4a/connect 4.0.0-beta.9 → 4.0.0

package/infra/hasura-graphql/types/graphql.repository.type.d.ts

@@ -1,21 +1,24 @@
+import { IOperation } from 'gql-query-builder/build/IQueryBuilderOptions';
 import { BaseModelBuilder, ModelBaseStructure } from '../../../domain';
+import { DebugHelper } from '../../../utils';
 import { HasuraGraphQLAuthOptions } from './hasura-graphql-auth-options.type';
 import { HasuraGraphQLFields } from './hasura-graphql-fields.type';
 import { VariableOptions } from './variable-options.type';
-export declare type GraphQLParams<Model extends ModelBaseStructure> = {
-    operation: string;
+export declare type GraphQLParams<Model extends ModelBaseStructure<Model>> = {
+    operation: string | IOperation;
     fields?: HasuraGraphQLFields<Model>;
     variables?: VariableOptions;
 };
-export declare type GraphQLRepository<Model extends ModelBaseStructure> = {
+export declare type GraphQLRepository<Model extends ModelBaseStructure<Model>> = {
     tableName: string;
     model: BaseModelBuilder<Model>;
     fields: HasuraGraphQLFields<Model>;
     endpoint: string;
     authOptions: HasuraGraphQLAuthOptions;
-    mutation: <ReturnFields = any>(operation: string, fields?: HasuraGraphQLFields<Model>, variables?: VariableOptions) => Promise<ReturnFields>;
-    query: <ReturnFields = any>(operation: string | GraphQLParams<Model>[], fields?: HasuraGraphQLFields<Model>, variables?: VariableOptions) => Promise<ReturnFields>;
+    logger: DebugHelper;
+    mutation: <ReturnFields = any>(operation: string | IOperation, fields?: string[] | HasuraGraphQLFields<Model>, variables?: VariableOptions) => Promise<ReturnFields>;
+    query: <ReturnFields = any>(operation: string | IOperation | GraphQLParams<Model>[], fields?: string[] | HasuraGraphQLFields<Model>, variables?: VariableOptions) => Promise<ReturnFields>;
     getAttributeGraphQLTypeOf: <FieldValue>(value: FieldValue) => string;
-    convertDataFromHasura: (data: Record<string, string | number>) => Model;
+    convertDataFromHasura(data: Record<string, string | number>, fields?: string[] | HasuraGraphQLFields<Model>): Model;
     convertDataToHasura(instance: Model, update?: boolean): Record<string, string | number>;
 };

package/infra/hasura-graphql/types/hasura-graphql-fields.type.d.ts

@@ -8,7 +8,7 @@ export declare type ColumnOptions<FieldType, Model, ValueFrom = any> = {
         filterType: HasuraGraphQLColumnType | string;
         filters: NestedRepositoryFindFieltersOptions<FieldType>;
     };
-    fields?: HasuraGraphQLFields<FieldType extends any[] ? FieldType[number] : FieldType>;
+    fields?: HasuraGraphQLFields<FieldType>;
     foreignKeyColumn?: Partial<Record<NonFunctionAndIdentifierPropertyNames<FieldType extends any[] ? FieldType[number] : FieldType>, NonFunctionAndIdentifierPropertyNames<Model> | (string & {})>> | {};
     from?: (value: ValueFrom | ValueFrom[], data?: any) => FieldType;
     to?: (value: FieldType, instance?: Model) => ValueFrom;
@@ -31,10 +31,14 @@ export declare type AggregateOptions<Model> = {
     var_samp?: Array<AggregateOptionFields<Model, number>>;
     variance?: Array<AggregateOptionFields<Model, number>>;
 };
-export declare type HasuraGraphQLFields<Model> = ((Model extends ModelBaseStructure ? NonFunctionAndIdentifierPropertyNames<Model> | {
+declare type ModelBaseHasuraGraphQLFields<Model> = Model extends ModelBaseStructure ? NonFunctionAndIdentifierPropertyNames<Model> | {
     [key in NonFunctionAndIdentifierPropertyNames<Model>]?: PropType<Model, key> extends ModelBaseStructure ? HasuraGraphQLFields<PropType<Model, key>> : PropType<Model, key> extends any[] ? PropType<Model, key>[] extends ModelBaseStructure[] ? HasuraGraphQLFields<PropType<Model, key>[]> : never : never;
 } | {
     [key in NonFunctionAndIdentifierPropertyNames<Model>]?: key extends 'aggregate' ? never : PropType<Model, key> extends ModelBaseStructure ? ColumnOptions<PropType<Model, key>, Model> : ColumnOptions<PropType<Model, key>, Model>;
-} | (string & {}) : string) | {
+} | Record<string, ColumnOptions<PropType<Model, any>, Model>> : string;
+export declare type HasuraGraphQLFields<Model> = (ModelBaseHasuraGraphQLFields<Model> | {
     aggregate: Array<AggregateOptions<Model> | 'count'>;
+} | {
+    returning: NonFunctionAndIdentifierPropertyNames<Model>[];
 } | 'affected_rows')[];
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@infrab4a/connect",
-  "version": "4.0.0-beta.9",
+  "version": "4.0.0",
   "publishConfig": {
     "registry": "https://registry.npmjs.org"
   },
@@ -12,6 +12,7 @@
     "axios": "^0.27.2",
     "class-transformer": "^0.5.1",
     "date-fns": "^2.28.0",
+    "debug": "^4.3.4",
     "firebase": "^9.9.0",
     "gql-query-builder": "3.7.0",
     "lodash": "^4.17.21",

package/utils/decorators/debug.class.decorator.d.ts

@@ -0,0 +1,2 @@
+import { DebugOptions } from '../helpers';
+export declare function Debug(opts?: DebugOptions): ClassDecorator;

package/utils/decorators/index.d.ts

@@ -0,0 +1,2 @@
+export * from './debug.class.decorator';
+export * from './trace.method.decorator';

package/utils/decorators/trace.method.decorator.d.ts

@@ -0,0 +1,14 @@
+export declare type CallbackFnArgs<T, Result> = {
+    target: T;
+    result: Result;
+    args: Array<any>;
+    namespace?: Array<string>;
+};
+declare type CallbackFn<T, Result> = (opts: CallbackFnArgs<T, Result>) => void;
+declare type TraceOptions<T, Result> = {
+    callbackFn?: CallbackFn<T, Result>;
+    level?: 'trace' | 'log';
+};
+export declare function Log<T, Result>(options?: TraceOptions<T, Result>): (target: any, propertyKey: string, propertyDescriptor: PropertyDescriptor) => PropertyDescriptor;
+export declare function Trace<T, Result>(options?: TraceOptions<T, Result>): (target: any, propertyKey: string, propertyDescriptor: PropertyDescriptor) => PropertyDescriptor;
+export {};

package/utils/helpers/class-name.helper.d.ts

@@ -0,0 +1,3 @@
+export declare class ClassNameHelper {
+    static get(clazz: any): string;
+}

package/utils/helpers/debug-decorator.helper.d.ts

@@ -0,0 +1,9 @@
+export declare type DebugOptions = {
+    name?: string;
+    namespaces?: Array<string>;
+};
+export declare class DebugDecoratorHelper {
+    static DebugNamingMetadataKey: string;
+    static set(target: object, options: DebugOptions): void;
+    static get(target: object): DebugOptions;
+}

package/utils/helpers/debug.helper.d.ts

@@ -0,0 +1,60 @@
+import { Debugger } from 'debug';
+import { Subject } from 'rxjs';
+export declare type Debuggable = {
+    debug: DebugHelper;
+};
+declare type DebugLog = {
+    namespace: string;
+    message: string;
+    args: Array<any>;
+};
+declare type DebugError = {
+    namespace: string;
+    error: any;
+    args: Array<any>;
+};
+export declare const isDebuggable: (object: any) => object is Debuggable;
+export declare class DebugHelper {
+    static logs$: Subject<DebugLog>;
+    static traces$: Subject<DebugLog>;
+    static errors$: Subject<DebugError>;
+    static isDebuggable: (object: any) => object is Debuggable;
+    static namespacesFor(target: object): Array<string>;
+    static as(...namespaces: Array<string>): DebugHelper;
+    static for(target: object, ...namespaces: Array<string>): DebugHelper;
+    static from(target: object, ...namespaces: Array<string>): DebugHelper;
+    static clonedFrom(target: object, ...namespaces: Array<string>): DebugHelper;
+    static clone(target: object, ...namespaces: Array<string>): {
+        original: DebugHelper;
+        debug: DebugHelper;
+    };
+    static replace(target: any, attrs: {
+        with: DebugHelper;
+    }): void;
+    static mock(target: object, ...namespaces: Array<string>): {
+        original: DebugHelper;
+        debug: DebugHelper;
+    };
+    logger: Debugger;
+    tracer: Debugger;
+    err: Debugger;
+    namespaces: Set<string>;
+    constructor(...namespace: Array<string>);
+    get entries(): Array<string>;
+    get namespace(): string;
+    log(message?: any, ...args: Array<any>): DebugHelper;
+    trace(message?: any, ...args: Array<any>): DebugHelper;
+    error(error: any, ...args: Array<any>): DebugHelper;
+    build(): DebugHelper;
+    with(...namespace: Array<string>): DebugHelper;
+    push(...namespace: Array<string>): DebugHelper;
+    unshift(...namespace: Array<string>): DebugHelper;
+    reset(...namespace: Array<string>): DebugHelper;
+    startWith(...namespace: Array<string>): DebugHelper;
+    shift(): DebugHelper;
+    pop(): DebugHelper;
+    clear(): DebugHelper;
+    remove(...namespace: Array<string>): DebugHelper;
+    puts(...args: Array<string>): string;
+}
+export {};

package/utils/helpers/index.d.ts

@@ -0,0 +1,4 @@
+export * from './debug.helper';
+export * from './reflect.helper';
+export * from './class-name.helper';
+export * from './debug-decorator.helper';

package/utils/helpers/reflect.helper.d.ts

@@ -0,0 +1,50 @@
+import 'reflect-metadata';
+declare type Dictionary<T> = {
+    [key: string]: T;
+};
+export declare type MetaArgs = {
+    key: keyof MetaStorage | string;
+    target: any;
+    property?: string | symbol;
+    own?: boolean;
+    propertyDescriptor?: PropertyDescriptor;
+};
+export declare type MetaValueArgs<T = any> = MetaArgs & {
+    value: T;
+};
+declare type MetaProperties<T = any> = Dictionary<T>;
+declare type MetaTargets = Dictionary<MetaProperties>;
+declare type MetaKeys = Dictionary<MetaTargets>;
+declare type MetaStorage = {
+    value?: any;
+    object?: any;
+    values?: MetaKeys;
+} & Record<string, any>;
+export declare class ReflectHelper {
+    static get items(): MetaStorage;
+    static get keys(): Array<string>;
+    static has(key: keyof MetaStorage, target?: any, property?: string | symbol): boolean;
+    static get<T = any>({ key, target, property, own }: MetaArgs): Array<T>;
+    static first<T = any>({ key, target, property, own }: MetaArgs): T;
+    static last<T = any>({ key, target, property, own }: MetaArgs): T;
+    static set<T = any>({ key, target, property, value, propertyDescriptor }: MetaValueArgs<T>): void;
+    static add<T = any>({ key, target, property, value, propertyDescriptor }: MetaValueArgs<T>): void;
+    static all<T = any>({ key }: Partial<MetaArgs>): Array<MetaValueArgs<T>>;
+    static allFrom(key: string, target: any): any;
+    static allValuesFrom(key: string, target: any, property: any): any;
+    static delete({ key, target, property }: MetaArgs): boolean;
+    static clear(key?: string): void;
+    static getType({ target, propertyKey }: {
+        target: string;
+        propertyKey: string;
+    }): any;
+    static getReturntype({ target, propertyKey }: {
+        target: string;
+        propertyKey: string;
+    }): any;
+    static getAllMethods(target: any): string[];
+    private static _items;
+    private static put;
+    private static remove;
+}
+export {};

package/utils/index.d.ts

@@ -1,10 +1,13 @@
 import { add, addBusinessDays, addDays, addMonths, addYears, Duration, endOfDay, format, formatISO9075, parseISO, startOfDay, sub } from 'date-fns';
-import { chunk, isBoolean, isDate, isEmpty, isInteger, isNaN, isNil, isNumber, isObject, isString, now, omit, pick, set } from 'lodash';
+import { chunk, each, get, isBoolean, isDate, isEmpty, isInteger, isNaN, isNil, isNumber, isObject, isString, now, omit, pick, set, unset } from 'lodash';
 export declare type DateDuration = Duration;
+export * from './decorators';
 export * from './get';
+export * from './helpers';
 export * from './is';
 export * from './is-uuid';
+export * from './log.utils';
 export * from './mixins';
 export * from './parse-datetime';
 export * from './types';
-export { add, addDays, addBusinessDays, addMonths, addYears, chunk, endOfDay, format, formatISO9075, isBoolean, isDate, isEmpty, isInteger, isNil, isNaN, isNumber, isObject, isString, parseISO, now, omit, pick, set, startOfDay, sub, };
+export { add, addDays, addBusinessDays, addMonths, addYears, chunk, each, endOfDay, format, formatISO9075, get, isBoolean, isDate, isEmpty, isInteger, isNil, isNaN, isNumber, isObject, isString, parseISO, now, omit, pick, set, startOfDay, sub, unset, };

package/utils/log.utils.d.ts

@@ -0,0 +1,7 @@
+import { Debugger } from 'debug';
+export declare enum DebugNamespaces {
+    ROOT = "connect",
+    TRACE = "trace",
+    ERROR = "error"
+}
+export declare const Logger: Debugger;

package/domain/catalog/models/types/category-filter.type.d.ts

@@ -1,4 +0,0 @@
-export declare type CategoryFilter = {
-    name?: string;
-    tags?: string[];
-};

package/esm2020/domain/catalog/models/types/category-filter.type.mjs

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2F0ZWdvcnktZmlsdGVyLnR5cGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9jb25uZWN0L3NyYy9kb21haW4vY2F0YWxvZy9tb2RlbHMvdHlwZXMvY2F0ZWdvcnktZmlsdGVyLnR5cGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCB0eXBlIENhdGVnb3J5RmlsdGVyID0ge1xuICBuYW1lPzogc3RyaW5nXG4gIHRhZ3M/OiBzdHJpbmdbXVxufVxuIl19