@fjell/lib-sequelize 4.4.0 → 4.4.2

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/types/AggregationBuilder.d.ts

@@ -0,0 +1,4 @@
+import { Item } from '@fjell/core';
+import { AggregationDefinition } from './Options';
+import * as Library from "@fjell/lib";
+export declare const buildAggregation: (item: Item, aggregationDefinition: AggregationDefinition, registry: Library.Registry) => Promise<Item<never, never, never, never, never, never>>;

package/dist/{Definition.d.ts → types/Definition.d.ts}

@@ -4,4 +4,4 @@ import * as Library from '@fjell/lib';
 export interface Definition<V extends Item<S, L1, L2, L3, L4, L5>, S extends string, L1 extends string = never, L2 extends string = never, L3 extends string = never, L4 extends string = never, L5 extends string = never> extends Library.Definition<V, S, L1, L2, L3, L4, L5> {
     options: Options<V, S, L1, L2, L3, L4, L5>;
 }
-export declare function createDefinition<V extends Item<S, L1, L2, L3, L4, L5>, S extends string, L1 extends string = never, L2 extends string = never, L3 extends string = never, L4 extends string = never, L5 extends string = never>(kta: ItemTypeArray<S, L1, L2, L3, L4, L5>, scopes: string[], libOptions?: Options<V, S, L1, L2, L3, L4, L5>): Definition<V, S, L1, L2, L3, L4, L5>;
+export declare function createDefinition<V extends Item<S, L1, L2, L3, L4, L5>, S extends string, L1 extends string = never, L2 extends string = never, L3 extends string = never, L4 extends string = never, L5 extends string = never>(kta: ItemTypeArray<S, L1, L2, L3, L4, L5>, scopes: string[], libOptions?: Partial<Options<V, S, L1, L2, L3, L4, L5>>): Definition<V, S, L1, L2, L3, L4, L5>;

package/dist/{EventCoordinator.d.ts → types/EventCoordinator.d.ts}

@@ -2,4 +2,5 @@ import { ItemProperties } from '@fjell/core';
 export declare const createEvents: <S extends string, L1 extends string = never, L2 extends string = never, L3 extends string = never, L4 extends string = never, L5 extends string = never>(item: ItemProperties<S, L1, L2, L3, L4, L5>) => ItemProperties<S, L1, L2, L3, L4, L5>;
 export declare const updateEvents: <S extends string, L1 extends string = never, L2 extends string = never, L3 extends string = never, L4 extends string = never, L5 extends string = never>(item: ItemProperties<S, L1, L2, L3, L4, L5>) => ItemProperties<S, L1, L2, L3, L4, L5>;
 export declare const populateEvents: <S extends string, L1 extends string = never, L2 extends string = never, L3 extends string = never, L4 extends string = never, L5 extends string = never>(item: ItemProperties<S, L1, L2, L3, L4, L5>) => ItemProperties<S, L1, L2, L3, L4, L5>;
+export declare const extractEvents: <S extends string, L1 extends string = never, L2 extends string = never, L3 extends string = never, L4 extends string = never, L5 extends string = never>(item: ItemProperties<S, L1, L2, L3, L4, L5>) => ItemProperties<S, L1, L2, L3, L4, L5>;
 export declare const removeEvents: <S extends string, L1 extends string = never, L2 extends string = never, L3 extends string = never, L4 extends string = never, L5 extends string = never>(item: ItemProperties<S, L1, L2, L3, L4, L5>) => ItemProperties<S, L1, L2, L3, L4, L5>;

package/dist/{Instance.d.ts → types/Instance.d.ts}

@@ -5,4 +5,4 @@ import * as Library from '@fjell/lib';
 export interface Instance<V extends Item<S, L1, L2, L3, L4, L5>, S extends string, L1 extends string = never, L2 extends string = never, L3 extends string = never, L4 extends string = never, L5 extends string = never> extends Library.Instance<V, S, L1, L2, L3, L4, L5> {
     models: ModelStatic<any>[];
 }
-export declare function createInstance<V extends Item<S, L1, L2, L3, L4, L5>, S extends string, L1 extends string = never, L2 extends string = never, L3 extends string = never, L4 extends string = never, L5 extends string = never>(keyTypes: ItemTypeArray<S, L1, L2, L3, L4, L5>, models: ModelStatic<any>[], libOptions?: Options<V, S, L1, L2, L3, L4, L5>, scopes?: string[]): Instance<V, S, L1, L2, L3, L4, L5>;
+export declare function createInstance<V extends Item<S, L1, L2, L3, L4, L5>, S extends string, L1 extends string = never, L2 extends string = never, L3 extends string = never, L4 extends string = never, L5 extends string = never>(keyTypes: ItemTypeArray<S, L1, L2, L3, L4, L5>, models: ModelStatic<any>[], libOptions: Partial<Options<V, S, L1, L2, L3, L4, L5>> | undefined, scopes: string[] | undefined, registry: Library.Registry): Instance<V, S, L1, L2, L3, L4, L5>;

package/dist/types/KeyMaster.d.ts

@@ -0,0 +1,4 @@
+import { AllItemTypeArrays, Item, ItemProperties } from '@fjell/core';
+import { Model } from 'sequelize';
+export declare const removeKey: <S extends string, L1 extends string = never, L2 extends string = never, L3 extends string = never, L4 extends string = never, L5 extends string = never>(item: ItemProperties<S, L1, L2, L3, L4, L5>) => ItemProperties<S, L1, L2, L3, L4, L5>;
+export declare const addKey: <S extends string, L1 extends string = never, L2 extends string = never, L3 extends string = never, L4 extends string = never, L5 extends string = never>(model: Model<any, any>, item: Partial<Item<S, L1, L2, L3, L4, L5>>, keyTypes: AllItemTypeArrays<S, L1, L2, L3, L4, L5>) => Item<S, L1, L2, L3, L4, L5>;

package/dist/{Operations.d.ts → types/Operations.d.ts}

@@ -1,5 +1,5 @@
 import { Item } from '@fjell/core';
 import { ModelStatic } from 'sequelize';
-import { Definition } from '@fjell/lib';
+import { Definition } from './Definition';
 import * as Library from "@fjell/lib";
-export declare const createOperations: <V extends Item<S, L1, L2, L3, L4, L5>, S extends string, L1 extends string = never, L2 extends string = never, L3 extends string = never, L4 extends string = never, L5 extends string = never>(models: Array<ModelStatic<any>>, definition: Definition<V, S, L1, L2, L3, L4, L5>) => Library.Operations<V, S, L1, L2, L3, L4, L5>;
+export declare const createOperations: <V extends Item<S, L1, L2, L3, L4, L5>, S extends string, L1 extends string = never, L2 extends string = never, L3 extends string = never, L4 extends string = never, L5 extends string = never>(models: Array<ModelStatic<any>>, definition: Definition<V, S, L1, L2, L3, L4, L5>, registry: Library.Registry) => Library.Operations<V, S, L1, L2, L3, L4, L5>;

package/dist/{Options.d.ts → types/Options.d.ts}

@@ -1,7 +1,18 @@
 import { Item } from '@fjell/core';
 import * as Library from '@fjell/lib';
+export interface AggregationDefinition {
+    kta: string[];
+    property: string;
+    cardinality: 'one' | 'many';
+}
+export interface ReferenceDefinition {
+    column: string;
+    kta: string[];
+    property: string;
+}
 export interface Options<V extends Item<S, L1, L2, L3, L4, L5>, S extends string, L1 extends string = never, L2 extends string = never, L3 extends string = never, L4 extends string = never, L5 extends string = never> extends Library.Options<V, S, L1, L2, L3, L4, L5> {
-    deleteOnRemove?: boolean;
+    deleteOnRemove: boolean;
+    references: ReferenceDefinition[];
+    aggregations: AggregationDefinition[];
 }
-export declare const defaultOptions: Options<any, any, any, any, any, any, any>;
-export declare const createOptions: <V extends Item<S, L1, L2, L3, L4, L5>, S extends string, L1 extends string = never, L2 extends string = never, L3 extends string = never, L4 extends string = never, L5 extends string = never>(libOptions?: Options<V, S, L1, L2, L3, L4, L5>) => Options<V, S, L1, L2, L3, L4, L5>;
+export declare const createOptions: <V extends Item<S, L1, L2, L3, L4, L5>, S extends string, L1 extends string = never, L2 extends string = never, L3 extends string = never, L4 extends string = never, L5 extends string = never>(libOptions?: Partial<Options<V, S, L1, L2, L3, L4, L5>>) => Options<V, S, L1, L2, L3, L4, L5>;

package/dist/{QueryBuilder.d.ts → types/QueryBuilder.d.ts}

@@ -5,6 +5,7 @@ export type QueryOptions = {
     limit?: number;
     offset?: number;
     order?: Array<[string, string]>;
+    include?: Array<any>;
 };
 export declare const addCompoundCondition: (options: any, compoundCondition: CompoundCondition, model: ModelStatic<any>) => any;
 export declare const addCondition: (conditions: Record<string, any>, condition: Condition, model: ModelStatic<any>) => Record<string, any>;

package/dist/types/ReferenceBuilder.d.ts

@@ -0,0 +1,3 @@
+import { ReferenceDefinition } from './Options';
+import * as Library from "@fjell/lib";
+export declare const buildReference: (item: any, referenceDefinition: ReferenceDefinition, registry: Library.Registry) => Promise<any>;

package/dist/{RowProcessor.d.ts → types/RowProcessor.d.ts}

@@ -1,3 +1,5 @@
 import { AllItemTypeArrays, Item } from '@fjell/core';
 import { Model } from 'sequelize';
-export declare const processRow: <S extends string, L1 extends string = never, L2 extends string = never, L3 extends string = never, L4 extends string = never, L5 extends string = never>(row: Model<any, any>, keyTypes: AllItemTypeArrays<S, L1, L2, L3, L4, L5>) => Item<S, L1, L2, L3, L4, L5>;
+import { AggregationDefinition, ReferenceDefinition } from './Options';
+import * as Library from "@fjell/lib";
+export declare const processRow: <S extends string, L1 extends string = never, L2 extends string = never, L3 extends string = never, L4 extends string = never, L5 extends string = never>(row: Model<any, any>, keyTypes: AllItemTypeArrays<S, L1, L2, L3, L4, L5>, referenceDefinitions: ReferenceDefinition[], aggregationDefinitions: AggregationDefinition[], registry: Library.Registry) => Promise<Item<S, L1, L2, L3, L4, L5>>;

package/dist/{contained → types/contained}/Instance.d.ts

@@ -2,7 +2,8 @@ import { Instance as AbstractSequelizeInstance } from '../Instance';
 import { Item, ItemTypeArray } from '@fjell/core';
 import { Contained } from '@fjell/lib';
 import { ModelStatic } from 'sequelize';
+import * as Library from "@fjell/lib";
 export interface Instance<V extends Item<S>, S extends string, L1 extends string = never, L2 extends string = never, L3 extends string = never, L4 extends string = never, L5 extends string = never> extends AbstractSequelizeInstance<V, S, L1, L2, L3, L4, L5> {
     models: ModelStatic<any>[];
 }
-export declare function createInstance<V extends Item<S, L1, L2, L3, L4, L5>, S extends string, L1 extends string = never, L2 extends string = never, L3 extends string = never, L4 extends string = never, L5 extends string = never>(keyTypes: ItemTypeArray<S, L1, L2, L3, L4, L5>, models: ModelStatic<any>[], libOptions?: Contained.Options<V, S, L1, L2, L3, L4, L5>, scopes?: string[]): Instance<V, S, L1, L2, L3, L4, L5>;
+export declare function createInstance<V extends Item<S, L1, L2, L3, L4, L5>, S extends string, L1 extends string = never, L2 extends string = never, L3 extends string = never, L4 extends string = never, L5 extends string = never>(keyTypes: ItemTypeArray<S, L1, L2, L3, L4, L5>, models: ModelStatic<any>[], libOptions: Contained.Options<V, S, L1, L2, L3, L4, L5> | undefined, scopes: string[] | undefined, registry: Library.Registry): Instance<V, S, L1, L2, L3, L4, L5>;

package/dist/{ops → types/ops}/all.d.ts

@@ -1,4 +1,5 @@
 import { Definition } from '../Definition';
 import { Item, ItemQuery, LocKeyArray } from '@fjell/core';
 import { ModelStatic } from 'sequelize';
-export declare const getAllOperation: <V extends Item<S, L1, L2, L3, L4, L5>, S extends string, L1 extends string = never, L2 extends string = never, L3 extends string = never, L4 extends string = never, L5 extends string = never>(models: ModelStatic<any>[], definition: Definition<V, S, L1, L2, L3, L4, L5>) => (itemQuery: ItemQuery, locations?: LocKeyArray<L1, L2, L3, L4, L5> | [] | undefined) => Promise<V[]>;
+import * as Library from "@fjell/lib";
+export declare const getAllOperation: <V extends Item<S, L1, L2, L3, L4, L5>, S extends string, L1 extends string = never, L2 extends string = never, L3 extends string = never, L4 extends string = never, L5 extends string = never>(models: ModelStatic<any>[], definition: Definition<V, S, L1, L2, L3, L4, L5>, registry: Library.Registry) => (itemQuery: ItemQuery, locations?: LocKeyArray<L1, L2, L3, L4, L5> | [] | undefined) => Promise<V[]>;

package/dist/{ops → types/ops}/create.d.ts

@@ -1,7 +1,8 @@
 import { ComKey, Item, LocKeyArray, PriKey, TypesProperties } from '@fjell/core';
-import { ModelStatic } from 'sequelize';
 import { Definition } from '../Definition';
-export declare const getCreateOperation: <V extends Item<S, L1, L2, L3, L4, L5>, S extends string, L1 extends string = never, L2 extends string = never, L3 extends string = never, L4 extends string = never, L5 extends string = never>(models: ModelStatic<any>[], definition: Definition<V, S, L1, L2, L3, L4, L5>) => (item: TypesProperties<V, S, L1, L2, L3, L4, L5>, options?: {
+import { ModelStatic } from 'sequelize';
+import * as Library from "@fjell/lib";
+export declare const getCreateOperation: <V extends Item<S, L1, L2, L3, L4, L5>, S extends string, L1 extends string = never, L2 extends string = never, L3 extends string = never, L4 extends string = never, L5 extends string = never>(models: ModelStatic<any>[], definition: Definition<V, S, L1, L2, L3, L4, L5>, registry: Library.Registry) => (item: TypesProperties<V, S, L1, L2, L3, L4, L5>, options?: {
     key: PriKey<S> | ComKey<S, L1, L2, L3, L4, L5>;
     locations?: never;
 } | {

package/dist/{ops → types/ops}/find.d.ts

@@ -1,4 +1,5 @@
 import { Item, LocKeyArray } from '@fjell/core';
 import { Definition } from '../Definition';
 import { ModelStatic } from 'sequelize';
-export declare const getFindOperation: <V extends Item<S, L1, L2, L3, L4, L5>, S extends string, L1 extends string = never, L2 extends string = never, L3 extends string = never, L4 extends string = never, L5 extends string = never>(models: ModelStatic<any>[], definition: Definition<V, S, L1, L2, L3, L4, L5>) => (finder: string, finderParams: Record<string, string | number | boolean | Date | Array<string | number | boolean | Date>>, locations?: LocKeyArray<L1, L2, L3, L4, L5> | []) => Promise<V[]>;
+import * as Library from "@fjell/lib";
+export declare const getFindOperation: <V extends Item<S, L1, L2, L3, L4, L5>, S extends string, L1 extends string = never, L2 extends string = never, L3 extends string = never, L4 extends string = never, L5 extends string = never>(models: ModelStatic<any>[], definition: Definition<V, S, L1, L2, L3, L4, L5>, registry: Library.Registry) => (finder: string, finderParams: Record<string, string | number | boolean | Date | Array<string | number | boolean | Date>>, locations?: LocKeyArray<L1, L2, L3, L4, L5> | []) => Promise<V[]>;

package/dist/{ops → types/ops}/get.d.ts

@@ -1,4 +1,5 @@
 import { ComKey, Item, PriKey } from '@fjell/core';
 import { ModelStatic } from 'sequelize';
 import { Definition } from '../Definition';
-export declare const getGetOperation: <V extends Item<S, L1, L2, L3, L4, L5>, S extends string, L1 extends string = never, L2 extends string = never, L3 extends string = never, L4 extends string = never, L5 extends string = never>(models: Array<ModelStatic<any>>, definition: Definition<V, S, L1, L2, L3, L4, L5>) => (key: PriKey<S> | ComKey<S, L1, L2, L3, L4, L5>) => Promise<V>;
+import * as Library from "@fjell/lib";
+export declare const getGetOperation: <V extends Item<S, L1, L2, L3, L4, L5>, S extends string, L1 extends string = never, L2 extends string = never, L3 extends string = never, L4 extends string = never, L5 extends string = never>(models: Array<ModelStatic<any>>, definition: Definition<V, S, L1, L2, L3, L4, L5>, registry: Library.Registry) => (key: PriKey<S> | ComKey<S, L1, L2, L3, L4, L5>) => Promise<V>;

package/dist/{ops → types/ops}/one.d.ts

@@ -1,4 +1,5 @@
 import { Item, ItemQuery, LocKeyArray } from '@fjell/core';
 import { Definition } from '../Definition';
 import { ModelStatic } from 'sequelize';
-export declare const getOneOperation: <V extends Item<S, L1, L2, L3, L4, L5>, S extends string, L1 extends string = never, L2 extends string = never, L3 extends string = never, L4 extends string = never, L5 extends string = never>(models: ModelStatic<any>[], definition: Definition<V, S, L1, L2, L3, L4, L5>) => (itemQuery: ItemQuery, locations?: LocKeyArray<L1, L2, L3, L4, L5> | []) => Promise<V | null>;
+import * as Library from "@fjell/lib";
+export declare const getOneOperation: <V extends Item<S, L1, L2, L3, L4, L5>, S extends string, L1 extends string = never, L2 extends string = never, L3 extends string = never, L4 extends string = never, L5 extends string = never>(models: ModelStatic<any>[], definition: Definition<V, S, L1, L2, L3, L4, L5>, registry: Library.Registry) => (itemQuery: ItemQuery, locations?: LocKeyArray<L1, L2, L3, L4, L5> | []) => Promise<V | null>;

package/dist/{ops → types/ops}/remove.d.ts

@@ -1,4 +1,5 @@
 import { ComKey, PriKey, Item } from '@fjell/core';
 import { Definition } from '../Definition';
 import { ModelStatic } from 'sequelize';
-export declare const getRemoveOperation: <V extends Item<S, L1, L2, L3, L4, L5>, S extends string, L1 extends string = never, L2 extends string = never, L3 extends string = never, L4 extends string = never, L5 extends string = never>(models: ModelStatic<any>[], definition: Definition<V, S, L1, L2, L3, L4, L5>) => (key: PriKey<S> | ComKey<S, L1, L2, L3, L4, L5>) => Promise<V>;
+import * as Library from "@fjell/lib";
+export declare const getRemoveOperation: <V extends Item<S, L1, L2, L3, L4, L5>, S extends string, L1 extends string = never, L2 extends string = never, L3 extends string = never, L4 extends string = never, L5 extends string = never>(models: ModelStatic<any>[], definition: Definition<V, S, L1, L2, L3, L4, L5>, registry: Library.Registry) => (key: PriKey<S> | ComKey<S, L1, L2, L3, L4, L5>) => Promise<V>;

package/dist/{ops → types/ops}/update.d.ts

@@ -1,4 +1,5 @@
 import { ComKey, Item, PriKey, TypesProperties } from '@fjell/core';
 import { Definition } from '../Definition';
 import { ModelStatic } from 'sequelize';
-export declare const getUpdateOperation: <V extends Item<S, L1, L2, L3, L4, L5>, S extends string, L1 extends string = never, L2 extends string = never, L3 extends string = never, L4 extends string = never, L5 extends string = never>(models: ModelStatic<any>[], definition: Definition<V, S, L1, L2, L3, L4, L5>) => (key: PriKey<S> | ComKey<S, L1, L2, L3, L4, L5>, item: TypesProperties<V, S, L1, L2, L3, L4, L5>) => Promise<V>;
+import * as Library from "@fjell/lib";
+export declare const getUpdateOperation: <V extends Item<S, L1, L2, L3, L4, L5>, S extends string, L1 extends string = never, L2 extends string = never, L3 extends string = never, L4 extends string = never, L5 extends string = never>(models: ModelStatic<any>[], definition: Definition<V, S, L1, L2, L3, L4, L5>, registry: Library.Registry) => (key: PriKey<S> | ComKey<S, L1, L2, L3, L4, L5>, item: TypesProperties<V, S, L1, L2, L3, L4, L5>) => Promise<V>;

package/dist/{primary → types/primary}/Instance.d.ts

@@ -2,7 +2,8 @@ import { Instance as AbstractSequelizeInstance } from '../Instance';
 import { Item } from '@fjell/core';
 import { ModelStatic } from 'sequelize';
 import { Options } from '../Options';
+import * as Library from "@fjell/lib";
 export interface Instance<V extends Item<S>, S extends string> extends AbstractSequelizeInstance<V, S> {
     models: ModelStatic<any>[];
 }
-export declare function createInstance<V extends Item<S>, S extends string>(keyType: S, models: ModelStatic<any>[], libOptions?: Options<V, S>, scopes?: string[]): Instance<V, S>;
+export declare function createInstance<V extends Item<S>, S extends string>(keyType: S, models: ModelStatic<any>[], libOptions: Partial<Options<V, S>> | undefined, scopes: string[] | undefined, registry: Library.Registry): Instance<V, S>;

package/dist/types/util/general.d.ts

@@ -0,0 +1,4 @@
+export declare const clean: (obj: any) => {
+    [k: string]: unknown;
+};
+export declare const stringifyJSON: (obj: any, visited?: Set<any>) => string;

package/dist/types/util/relationshipUtils.d.ts

@@ -0,0 +1,21 @@
+import { ModelStatic } from 'sequelize';
+export interface RelationshipChainResult {
+    success: boolean;
+    path?: string;
+    includes?: any[];
+}
+export interface RelationshipPathResult {
+    found: boolean;
+    path?: string;
+    includes?: any[];
+    isDirect?: boolean;
+}
+/**
+ * Helper function to build relationship chain includes
+ */
+export declare const buildRelationshipChain: (targetModel: ModelStatic<any>, kta: string[], currentIndex: number, targetIndex: number) => RelationshipChainResult;
+/**
+ * Helper function to build relationship path for a locator
+ * @param includeIsDirect Whether to include the isDirect flag in the result
+ */
+export declare const buildRelationshipPath: (targetModel: ModelStatic<any>, locatorType: string, kta: string[], includeIsDirect?: boolean) => RelationshipPathResult;

package/package.json

@@ -1,57 +1,61 @@
 {
   "name": "@fjell/lib-sequelize",
-  "version": "4.4.0",
+  "version": "4.4.2",
   "license": "Apache-2.0",
   "description": "Sequelize Library for Fjell",
   "engines": {
     "node": ">=21"
   },
-  "main": "dist/index.js",
+  "main": "./dist/cjs/index.cjs",
+  "module": "./dist/es/index.js",
+  "type": "module",
+  "types": "./dist/types/index.d.ts",
   "exports": {
     ".": {
-      "types": "./dist/index.d.ts",
-      "require": "./dist/index.js",
-      "import": "./dist/index.js"
+      "types": "./dist/types/index.d.ts",
+      "import": "./dist/es/index.js",
+      "require": "./dist/cjs/index.cjs"
     }
   },
-  "type": "module",
+  "files": [
+    "dist"
+  ],
   "dependencies": {
-    "@fjell/core": "^4.4.2",
-    "@fjell/lib": "^4.4.0",
-    "@fjell/logging": "^4.4.2",
+    "@fjell/core": "^4.4.3",
+    "@fjell/lib": "^4.4.2",
+    "@fjell/logging": "^4.4.3",
     "dayjs": "^1.11.13",
     "deepmerge": "^4.3.1",
-    "multer": "^1.4.5-lts.1",
-    "sequelize": "^6.37.5",
+    "multer": "2.0.1",
+    "sequelize": "^6.37.7",
     "specifier-resolution-node": "^1.1.4",
     "winston": "^3.17.0"
   },
   "devDependencies": {
-    "@babel/preset-env": "^7.26.9",
-    "@babel/preset-react": "^7.26.3",
-    "@babel/preset-typescript": "^7.26.0",
+    "@babel/preset-env": "^7.27.2",
+    "@babel/preset-react": "^7.27.1",
+    "@babel/preset-typescript": "^7.27.1",
     "@eslint/eslintrc": "^3.3.1",
-    "@eslint/js": "^9.27.0",
-    "@jest/globals": "^29.7.0",
-    "@swc/core": "^1.11.24",
-    "@tsconfig/recommended": "^1.0.8",
-    "@types/jest": "^29.5.14",
-    "@types/multer": "^1.4.12",
-    "@types/node": "^20.17.19",
-    "@typescript-eslint/eslint-plugin": "^8.32.1",
-    "@typescript-eslint/parser": "^8.32.1",
-    "concurrently": "^8.2.2",
-    "eslint": "^9.27.0",
-    "jest": "^29.7.0",
-    "nodemon": "^3.1.9",
+    "@eslint/js": "^9.29.0",
+    "@swc/core": "^1.12.5",
+    "@tsconfig/recommended": "^1.0.10",
+    "@types/multer": "^1.4.13",
+    "@types/node": "^24.0.3",
+    "@typescript-eslint/eslint-plugin": "^8.34.1",
+    "@typescript-eslint/parser": "^8.34.1",
+    "@vitest/coverage-v8": "^3.2.4",
+    "@vitest/ui": "^3.2.4",
+    "concurrently": "^9.1.2",
+    "eslint": "^9.29.0",
+    "nodemon": "^3.1.10",
     "rimraf": "^6.0.1",
-    "ts-jest": "^29.2.5",
     "ts-node": "^10.9.2",
-    "tsc-alias": "^1.8.10",
-    "typescript": "^5.7.3",
+    "tsc-alias": "^1.8.16",
+    "typescript": "^5.8.3",
     "vite": "^6.3.5",
     "vite-plugin-dts": "^4.5.4",
-    "vite-plugin-node": "^5.0.1"
+    "vite-plugin-node": "^5.0.1",
+    "vitest": "^3.2.4"
   },
   "repository": {
     "type": "git",
@@ -59,8 +63,9 @@
   },
   "scripts": {
     "build": "tsc --noEmit && vite build",
+    "dev": "vite build --watch",
     "lint": "eslint . --ext .ts --fix",
     "clean": "rimraf dist",
-    "test": "pnpm run lint && NODE_OPTIONS=\"$NODE_OPTIONS --experimental-vm-modules\" jest --coverage"
+    "test": "vitest run --coverage"
   }
 }

package/dist/EventCoordinator.js

@@ -1,30 +0,0 @@
-import 'deepmerge';
-import LibLogger from './logger.js';
-
-const logger = LibLogger.get("sequelize", "EventCoordinator");
-//#endregion
-const populateEvents = (item)=>{
-    const events = {
-        created: {
-            at: item.createdAt
-        },
-        updated: {
-            at: item.updatedAt
-        },
-        deleted: {
-            at: null
-        }
-    };
-    item.events = events;
-    return item;
-};
-const removeEvents = (item)=>{
-    logger.default('Removing Events', {
-        item
-    });
-    delete item.events;
-    return item;
-};
-
-export { populateEvents, removeEvents };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiRXZlbnRDb29yZGluYXRvci5qcyIsInNvdXJjZXMiOltdLCJzb3VyY2VzQ29udGVudCI6W10sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OzsifQ==

package/dist/KeyMaster.d.ts

@@ -1,4 +0,0 @@
-import { AllItemTypeArrays, Item, ItemProperties } from '@fjell/core';
-export declare const removeKey: <S extends string, L1 extends string = never, L2 extends string = never, L3 extends string = never, L4 extends string = never, L5 extends string = never>(item: ItemProperties<S, L1, L2, L3, L4, L5>) => ItemProperties<S, L1, L2, L3, L4, L5>;
-export declare const populateKey: <S extends string, L1 extends string = never, L2 extends string = never, L3 extends string = never, L4 extends string = never, L5 extends string = never>(item: ItemProperties<S, L1, L2, L3, L4, L5>, keyTypes: AllItemTypeArrays<S, L1, L2, L3, L4, L5>) => ItemProperties<S, L1, L2, L3, L4, L5>;
-export declare const addKey: <S extends string, L1 extends string = never, L2 extends string = never, L3 extends string = never, L4 extends string = never, L5 extends string = never>(item: Partial<Item<S, L1, L2, L3, L4, L5>>, keyTypes: AllItemTypeArrays<S, L1, L2, L3, L4, L5>) => void;

package/dist/KeyMaster.js

@@ -1,84 +0,0 @@
-import LibLogger from './logger.js';
-
-const logger = LibLogger.get('sequelize', 'KeyMaster');
-const removeKey = (item)=>{
-    logger.default('Removing Key', {
-        item
-    });
-    delete item.key;
-    return item;
-};
-const populateKey = (item, keyTypes)=>{
-    if (keyTypes.length === 1) {
-        item.key = {
-            kt: keyTypes[0],
-            pk: item.id
-        };
-        delete item.id;
-    } else if (keyTypes.length === 2) {
-        item.key = {
-            kt: keyTypes[0],
-            pk: item.id,
-            // TODO: Shouldn't this be inspecting the model to get the primary key type?
-            loc: [
-                {
-                    kt: keyTypes[1],
-                    lk: item[keyTypes[1] + 'Id']
-                }
-            ]
-        };
-        delete item.id;
-        delete item[keyTypes[1] + 'Id'];
-    } else {
-        throw new Error('Not implemented');
-    }
-    return item;
-};
-const addKey = (item, keyTypes)=>{
-    logger.default('Adding Key', {
-        item
-    });
-    const key = {};
-    if (Array.isArray(keyTypes) && keyTypes.length > 1) {
-        const type = [
-            ...keyTypes
-        ];
-        const pkType = type.shift();
-        Object.assign(key, {
-            kt: pkType,
-            pk: item.id
-        });
-        // TODO: This is really just for primary items
-        if (type.length === 1) {
-            // TODO: This should be looking at the model to get the primary key of the reference item or association
-            const locKeyTypeId = type[0] + 'Id';
-            Object.assign(key, {
-                loc: [
-                    {
-                        kt: type[0],
-                        lk: item[locKeyTypeId]
-                    }
-                ]
-            });
-        } else if (type.length === 2) {
-            throw new Error('Not implemented');
-        } else if (type.length === 3) {
-            throw new Error('Not implemented');
-        } else if (type.length === 4) {
-            throw new Error('Not implemented');
-        } else if (type.length === 5) {
-            throw new Error('Not implemented');
-        }
-    } else {
-        Object.assign(key, {
-            kt: keyTypes[0],
-            pk: item.id
-        });
-    }
-    Object.assign(item, {
-        key
-    });
-};
-
-export { addKey, populateKey, removeKey };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiS2V5TWFzdGVyLmpzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OyJ9

package/dist/RowProcessor.js

@@ -1,18 +0,0 @@
-import LibLogger from './logger.js';
-import { addKey } from './KeyMaster.js';
-
-const logger = LibLogger.get('sequelize', 'RowProcessor');
-const processRow = (row, keyTypes)=>{
-    logger.default('Processing Row', {
-        row
-    });
-    const item = row.get({
-        plain: true
-    });
-    addKey(item, keyTypes);
-    logger.default('Processed Row: ' + JSON.stringify(item));
-    return item;
-};
-
-export { processRow };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiUm93UHJvY2Vzc29yLmpzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7OyJ9

package/dist/ops/create.js

@@ -1,18 +0,0 @@
-import LibLogger from '../logger.js';
-
-const logger = LibLogger.get('sequelize', 'ops', 'create');
-const getCreateOperation = (// eslint-disable-next-line @typescript-eslint/no-unused-vars
-models, // eslint-disable-next-line @typescript-eslint/no-unused-vars
-definition)=>{
-    const create = async (item, options)=>{
-        logger.default('Create', {
-            item,
-            options
-        });
-        throw new Error('Not implemented');
-    };
-    return create;
-};
-
-export { getCreateOperation };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY3JlYXRlLmpzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7OyJ9

package/dist/ops/get.js

@@ -1,45 +0,0 @@
-import { isValidItemKey, isPriKey, isComKey, validateKeys } from '@fjell/core';
-import LibLogger from '../logger.js';
-import { processRow } from '../RowProcessor.js';
-import { NotFoundError } from '@fjell/lib';
-
-const logger = LibLogger.get('sequelize', 'ops', 'get');
-const getGetOperation = (models, definition)=>{
-    const { coordinate } = definition;
-    const { kta } = coordinate;
-    const get = async (key)=>{
-        logger.default('Get', {
-            key
-        });
-        if (!isValidItemKey(key)) {
-            logger.error('Key for Get is not a valid ItemKey: %j', key);
-            throw new Error('Key for Get is not a valid ItemKey');
-        }
-        const itemKey = key;
-        // @ts-ignore
-        const model = models[0];
-        let item;
-        if (isPriKey(itemKey)) {
-            item = await model.findByPk(itemKey.pk);
-        } else if (isComKey(itemKey)) {
-            var _comKey_loc_, _comKey_loc_1;
-            const comKey = itemKey;
-            // TODO: This should probably interrogate the model?
-            item = await model.findOne({
-                where: {
-                    id: comKey.pk,
-                    [(comKey === null || comKey === void 0 ? void 0 : (_comKey_loc_ = comKey.loc[0]) === null || _comKey_loc_ === void 0 ? void 0 : _comKey_loc_.kt) + 'Id']: comKey === null || comKey === void 0 ? void 0 : (_comKey_loc_1 = comKey.loc[0]) === null || _comKey_loc_1 === void 0 ? void 0 : _comKey_loc_1.lk
-                }
-            });
-        }
-        if (!item) {
-            throw new NotFoundError('get', coordinate, key);
-        } else {
-            return validateKeys(processRow(item, kta), kta);
-        }
-    };
-    return get;
-};
-
-export { getGetOperation };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2V0LmpzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OyJ9

package/src/Coordinate.ts

@@ -1,16 +0,0 @@
-import { ItemTypeArray } from '@fjell/core';
-import * as Library from '@fjell/lib';
-
-export const SCOPE_SEQUELIZE = 'sequelize';
-
-export const createCoordinate = <
-  S extends string,
-  L1 extends string = never,
-  L2 extends string = never,
-  L3 extends string = never,
-  L4 extends string = never,
-  L5 extends string = never
->(kta: ItemTypeArray<S, L1, L2, L3, L4, L5>, scopes?: string[]) => {
-  const coordinate = Library.createCoordinate(kta,[SCOPE_SEQUELIZE, ...(scopes || [])])
-  return coordinate;
-};

package/src/Definition.ts

@@ -1,49 +0,0 @@
-import {
-  Item,
-  ItemTypeArray
-} from '@fjell/core';
-  
-import * as Library from '@fjell/lib';
-import { createCoordinate } from './Coordinate';
-import { createOptions } from './Options';
-import { Options } from './Options';
-import LibLogger from './logger';
-
-const logger = LibLogger.get('lib-sequelize', 'Definition');
-  
-export interface Definition<
-    V extends Item<S, L1, L2, L3, L4, L5>,
-    S extends string,
-    L1 extends string = never,
-    L2 extends string = never,
-    L3 extends string = never,
-    L4 extends string = never,
-    L5 extends string = never
-  > extends Library.Definition<V, S, L1, L2, L3, L4, L5> {
-    options: Options<V, S, L1, L2, L3, L4, L5>;
-  }
-  
-export function createDefinition<
-    V extends Item<S, L1, L2, L3, L4, L5>,
-    S extends string,
-    L1 extends string = never,
-    L2 extends string = never,
-    L3 extends string = never,
-    L4 extends string = never,
-    L5 extends string = never
-  >(
-  kta: ItemTypeArray<S, L1, L2, L3, L4, L5>,
-  scopes: string[],
-  libOptions?: Options<V, S, L1, L2, L3, L4, L5>,
-): Definition<V, S, L1, L2, L3, L4, L5> {
-  logger.debug('createDefinition', { kta, scopes, libOptions });
-  const coordinate = createCoordinate(kta, scopes);
-  const options = createOptions(libOptions);
-  
-  const definition = Library.createDefinition(coordinate, options);
-  
-  return {
-    ...definition,
-    options,
-  }
-}