adding gitignore change

.gitignore

 # See https://help.github.com/articles/ignoring-files/ for more about ignoring files.
 
 # dependencies
-**/node_modules
-**/Backend/node_modules 
-**/frontend/node_modules
+/node_modules
+/backend/node_modules 
+/frontend/node_modules
 /.pnp
 .pnp.js
 

Backend/node_modules/sift/index.d.ts

-import sift from "./lib";
+import sift from "sift/lib";
 
 export default sift;
-export * from "./lib";
+export * from "sift/lib";

Backend/node_modules/sift/lib/core.d.ts

-import { Key, Comparator } from "./utils";
+import { Key, Comparator } from "sift/lib/utils";
 export interface Operation<TItem> {
     readonly keep: boolean;
     readonly done: boolean;

Backend/node_modules/sift/lib/index.d.ts

-import { Query, Options, createQueryTester, EqualsOperation, createQueryOperation, createEqualsOperation, createOperationTester } from "./core";
-declare const createDefaultQueryOperation: <TItem, TSchema extends TItem = TItem>(query: Query<TSchema>, ownerQuery: any, { compare, operations }?: Partial<Options>) => import("./core").QueryOperation<unknown>;
+import { Query, Options, createQueryTester, EqualsOperation, createQueryOperation, createEqualsOperation, createOperationTester } from "sift/lib/core";
+declare const createDefaultQueryOperation: <TItem, TSchema extends TItem = TItem>(query: Query<TSchema>, ownerQuery: any, { compare, operations }?: Partial<Options>) => import("sift/lib/core").QueryOperation<unknown>;
 declare const createDefaultQueryTester: <TItem, TSchema extends TItem = TItem>(query: Query<TSchema>, options?: Partial<Options>) => (item: unknown, key?: string | number, owner?: any) => boolean;
 export { Query, EqualsOperation, createQueryTester, createOperationTester, createDefaultQueryOperation, createEqualsOperation, createQueryOperation };
-export * from "./operations";
+export * from "sift/lib/operations";
 export default createDefaultQueryTester;

Backend/node_modules/sift/lib/operations.d.ts

-import { NamedBaseOperation, EqualsOperation, Options, Operation, Query, NamedGroupOperation } from "./core";
-import { Key } from "./utils";
+import { NamedBaseOperation, EqualsOperation, Options, Operation, Query, NamedGroupOperation } from "sift/lib/core";
+import { Key } from "sift/lib/utils";
 declare class $Ne extends NamedBaseOperation<any> {
     private _test;
     init(): void;
@@ -53,10 +53,10 @@ export declare const $nor: (params: any[], owneryQuery: any, options: Options, n
 export declare const $elemMatch: (params: any, owneryQuery: any, options: Options, name: string) => $ElemMatch;
 export declare const $nin: (params: any, owneryQuery: any, options: Options, name: string) => $Nin;
 export declare const $in: (params: any, owneryQuery: any, options: Options, name: string) => $In;
-export declare const $lt: (params: any, owneryQuery: any, options: Options, name: string) => Operation<any> | import("./core").NopeOperation<any>;
-export declare const $lte: (params: any, owneryQuery: any, options: Options, name: string) => Operation<any> | import("./core").NopeOperation<any>;
-export declare const $gt: (params: any, owneryQuery: any, options: Options, name: string) => Operation<any> | import("./core").NopeOperation<any>;
-export declare const $gte: (params: any, owneryQuery: any, options: Options, name: string) => Operation<any> | import("./core").NopeOperation<any>;
+export declare const $lt: (params: any, owneryQuery: any, options: Options, name: string) => Operation<any> | import("sift/lib/core").NopeOperation<any>;
+export declare const $lte: (params: any, owneryQuery: any, options: Options, name: string) => Operation<any> | import("sift/lib/core").NopeOperation<any>;
+export declare const $gt: (params: any, owneryQuery: any, options: Options, name: string) => Operation<any> | import("sift/lib/core").NopeOperation<any>;
+export declare const $gte: (params: any, owneryQuery: any, options: Options, name: string) => Operation<any> | import("sift/lib/core").NopeOperation<any>;
 export declare const $mod: ([mod, equalsValue]: number[], owneryQuery: any, options: Options) => EqualsOperation<(b: any) => boolean>;
 export declare const $exists: (params: boolean, owneryQuery: any, options: Options, name: string) => $Exists;
 export declare const $regex: (pattern: string, owneryQuery: any, options: Options) => EqualsOperation<RegExp>;

Backend/node_modules/type-fest/base.d.ts

@@ -2,37 +2,37 @@
 // It's shared between all TypeScript version-specific definitions.
 
 // Basic
-export * from './source/basic';
+export * from 'type-fest/source/basic';
 
 // Utilities
-export {Except} from './source/except';
-export {Mutable} from './source/mutable';
-export {Merge} from './source/merge';
-export {MergeExclusive} from './source/merge-exclusive';
-export {RequireAtLeastOne} from './source/require-at-least-one';
-export {RequireExactlyOne} from './source/require-exactly-one';
-export {PartialDeep} from './source/partial-deep';
-export {ReadonlyDeep} from './source/readonly-deep';
-export {LiteralUnion} from './source/literal-union';
-export {Promisable} from './source/promisable';
-export {Opaque} from './source/opaque';
-export {SetOptional} from './source/set-optional';
-export {SetRequired} from './source/set-required';
-export {ValueOf} from './source/value-of';
-export {PromiseValue} from './source/promise-value';
-export {AsyncReturnType} from './source/async-return-type';
-export {ConditionalExcept} from './source/conditional-except';
-export {ConditionalKeys} from './source/conditional-keys';
-export {ConditionalPick} from './source/conditional-pick';
-export {UnionToIntersection} from './source/union-to-intersection';
-export {Stringified} from './source/stringified';
-export {FixedLengthArray} from './source/fixed-length-array';
-export {IterableElement} from './source/iterable-element';
-export {Entry} from './source/entry';
-export {Entries} from './source/entries';
-export {SetReturnType} from './source/set-return-type';
-export {Asyncify} from './source/asyncify';
+export {Except} from 'type-fest/source/except';
+export {Mutable} from 'type-fest/source/mutable';
+export {Merge} from 'type-fest/source/merge';
+export {MergeExclusive} from 'type-fest/source/merge-exclusive';
+export {RequireAtLeastOne} from 'type-fest/source/require-at-least-one';
+export {RequireExactlyOne} from 'type-fest/source/require-exactly-one';
+export {PartialDeep} from 'type-fest/source/partial-deep';
+export {ReadonlyDeep} from 'type-fest/source/readonly-deep';
+export {LiteralUnion} from 'type-fest/source/literal-union';
+export {Promisable} from 'type-fest/source/promisable';
+export {Opaque} from 'type-fest/source/opaque';
+export {SetOptional} from 'type-fest/source/set-optional';
+export {SetRequired} from 'type-fest/source/set-required';
+export {ValueOf} from 'type-fest/source/value-of';
+export {PromiseValue} from 'type-fest/source/promise-value';
+export {AsyncReturnType} from 'type-fest/source/async-return-type';
+export {ConditionalExcept} from 'type-fest/source/conditional-except';
+export {ConditionalKeys} from 'type-fest/source/conditional-keys';
+export {ConditionalPick} from 'type-fest/source/conditional-pick';
+export {UnionToIntersection} from 'type-fest/source/union-to-intersection';
+export {Stringified} from 'type-fest/source/stringified';
+export {FixedLengthArray} from 'type-fest/source/fixed-length-array';
+export {IterableElement} from 'type-fest/source/iterable-element';
+export {Entry} from 'type-fest/source/entry';
+export {Entries} from 'type-fest/source/entries';
+export {SetReturnType} from 'type-fest/source/set-return-type';
+export {Asyncify} from 'type-fest/source/asyncify';
 
 // Miscellaneous
-export {PackageJson} from './source/package-json';
-export {TsConfigJson} from './source/tsconfig-json';
+export {PackageJson} from 'type-fest/source/package-json';
+export {TsConfigJson} from 'type-fest/source/tsconfig-json';

Backend/node_modules/type-fest/index.d.ts

 // These are all the basic types that's compatible with all supported TypeScript versions.
-export * from './base';
+export * from 'type-fest/base';

Backend/node_modules/type-fest/source/async-return-type.d.ts

-import {PromiseValue} from './promise-value';
+import {PromiseValue} from 'type-fest/source/promise-value';
 
 type AsyncFunction = (...args: any[]) => Promise<unknown>;
 

Backend/node_modules/type-fest/source/asyncify.d.ts

-import {PromiseValue} from './promise-value';
-import {SetReturnType} from './set-return-type';
+import {PromiseValue} from 'type-fest/source/promise-value';
+import {SetReturnType} from 'type-fest/source/set-return-type';
 
 /**
 Create an async version of the given function type, by boxing the return type in `Promise` while keeping the same parameter types.

Backend/node_modules/type-fest/source/conditional-except.d.ts

-import {Except} from './except';
-import {ConditionalKeys} from './conditional-keys';
+import {Except} from 'type-fest/source/except';
+import {ConditionalKeys} from 'type-fest/source/conditional-keys';
 
 /**
 Exclude keys from a shape that matches the given `Condition`.

Backend/node_modules/type-fest/source/conditional-pick.d.ts

-import {ConditionalKeys} from './conditional-keys';
+import {ConditionalKeys} from 'type-fest/source/conditional-keys';
 
 /**
 Pick keys from the shape that matches the given `Condition`.

Backend/node_modules/type-fest/source/entries.d.ts

-import {ArrayEntry, MapEntry, ObjectEntry, SetEntry} from './entry';
+import {ArrayEntry, MapEntry, ObjectEntry, SetEntry} from 'type-fest/source/entry';
 
 type ArrayEntries<BaseType extends readonly unknown[]> = Array<ArrayEntry<BaseType>>;
 type MapEntries<BaseType> = Array<MapEntry<BaseType>>;

Backend/node_modules/type-fest/source/literal-union.d.ts

-import {Primitive} from './basic';
+import {Primitive} from 'type-fest/source/basic';
 
 /**
 Allows creating a union type by combining primitive types and literal types without sacrificing auto-completion in IDEs for the literal type part of the union.

Backend/node_modules/type-fest/source/merge.d.ts

-import {Except} from './except';
+import {Except} from 'type-fest/source/except';
 
 /**
 Merge two types into a new type. Keys of the second type overrides keys of the first type.

Backend/node_modules/type-fest/source/package-json.d.ts

-import {LiteralUnion} from './literal-union';
+import {LiteralUnion} from 'type-fest/source/literal-union';
 
 declare namespace PackageJson {
 	/**

Backend/node_modules/type-fest/source/partial-deep.d.ts

-import {Primitive} from './basic';
+import {Primitive} from 'type-fest/source/basic';
 
 /**
 Create a type from another type with all keys and nested keys set to optional.

Backend/node_modules/type-fest/source/readonly-deep.d.ts

-import {Primitive} from './basic';
+import {Primitive} from 'type-fest/source/basic';
 
 /**
 Convert `object`s, `Map`s, `Set`s, and `Array`s and all of their keys/elements into immutable structures recursively.

Backend/node_modules/type-fest/source/require-at-least-one.d.ts

-import {Except} from './except';
+import {Except} from 'type-fest/source/except';
 
 /**
 Create a type that requires at least one of the given keys. The remaining keys are kept as is.

Backend/node_modules/type-fest/source/set-optional.d.ts

-import {Except} from './except';
+import {Except} from 'type-fest/source/except';
 
 /**
 Create a type that makes the given keys optional. The remaining keys are kept as is. The sister of the `SetRequired` type.