@fjell/lib-sequelize 4.4.0 → 4.4.1

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/{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/{KeyMaster.d.ts → types/KeyMaster.d.ts}

@@ -1,4 +1,3 @@
 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;
+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>) => 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/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 * 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/package.json

@@ -1,57 +1,61 @@
 {
   "name": "@fjell/lib-sequelize",
-  "version": "4.4.0",
+  "version": "4.4.1",
   "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.1",
+    "@fjell/logging": "^4.4.3",
     "dayjs": "^1.11.13",
     "deepmerge": "^4.3.1",
-    "multer": "^1.4.5-lts.1",
-    "sequelize": "^6.37.5",
+    "multer": "1.4.5-lts.2",
+    "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",
+    "@eslint/js": "^9.29.0",
+    "@swc/core": "^1.12.1",
+    "@tsconfig/recommended": "^1.0.9",
+    "@types/multer": "^1.4.13",
+    "@types/node": "^20.19.1",
+    "@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": "^8.2.2",
-    "eslint": "^9.27.0",
-    "jest": "^29.7.0",
-    "nodemon": "^3.1.9",
+    "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/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/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,
-  }
-}

package/src/EventCoordinator.ts

@@ -1,103 +0,0 @@
-import {
-  Evented,
-  ItemProperties,
-  ManagedEvents
-} from '@fjell/core';
-import deepmerge from 'deepmerge';
-  
-import LibLogger from '@/logger';
-  
-const logger = LibLogger.get("sequelize", "EventCoordinator");
-  
-export 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> => {
-  logger.default('Creating Events', { item });
-  const currentDate = new Date();
-  
-  let events = item.events;
-  
-  if (events) {
-    if (!events.created) {
-      events = deepmerge(events, { created: { at: currentDate } });
-    }
-    if (!events.updated) {
-      events = deepmerge(events, { updated: { at: currentDate } });
-    }
-    if (!events.deleted) {
-      events = deepmerge(events, { deleted: { at: null } });
-    }
-  
-  } else {
-    events = {
-      created: { at: currentDate },
-      updated: { at: currentDate },
-      deleted: { at: null },
-    };
-  }
-  
-  return deepmerge(item, { events }) as
-        ItemProperties<S, L1, L2, L3, L4, L5>;
-}
-  
-export 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> => {
-  logger.default('Updating Events', { item });
-  const currentDate = new Date();
-  const events: Evented = {
-    updated: { at: currentDate },
-  };
-  
-  // TODO: This is clean-up code, we should remove it
-  // If the event lacks a created data, let's just insert it here...
-  if (!item.events || !item.events.created || !item.events.created.at) {
-    events.created = { at: currentDate };
-  }
-  
-  return deepmerge(item, { events }) as ItemProperties<S, L1, L2, L3, L4, L5>;
-}
-//#endregion
-  
-export 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> => {
-  const events: ManagedEvents = {
-    created: { at: item.createdAt },
-    updated: { at: item.updatedAt },
-    deleted: { at: null }
-  };
-  item.events = events;
-  return item;
-}
-
-export 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> => {
-  logger.default('Removing Events', { item });
-  delete item.events;
-  return item;
-}
-  

package/src/Instance.ts

@@ -1,44 +0,0 @@
-import * as Library from '@fjell/lib';
-import { Item, ItemTypeArray } from '@fjell/core';
-import { createDefinition } from './Definition';
-import { createOperations } from './Operations';
-import { ModelStatic } from 'sequelize';
-import { Options } from './Options';
-
-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 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> {
-
-  const definition = createDefinition(keyTypes, scopes, libOptions);
-  const operations = createOperations(models, definition);
-
-  return {
-    definition,
-    operations: Library.wrapOperations(operations, definition),
-    models
-  }
-
-}

package/src/KeyMaster.ts

@@ -1,90 +0,0 @@
-import {
-  AllItemTypeArrays,
-  Item,
-  ItemProperties
-} from '@fjell/core';
-  
-import LibLogger from '@/logger';
-
-const logger = LibLogger.get('sequelize', 'KeyMaster');
-
-export 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> => {
-  logger.default('Removing Key', { item });
-  delete item.key;
-  return item;
-}
-  
-export 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> => {
-  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;
-}
-  
-export 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 => {
-  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 });
-};
-