@idb-orm/core 1.0.7 → 1.0.8

package/README.md

@@ -9,34 +9,31 @@
 -   [x] "Include" query field
     -   [x] Enforce that either "include" xor "select" is in the query object
     -   [x] modify the query object so that on relations it is recursive
--   [ ] Complete update action
-    -   [ ] Finish `updateSingleton` action
--   [ ] Unique model fields: Use "unique" indexes to enforce this.
--   [ ] Optimize batch `add` editing with cursor functionality
--   [ ] Make sure non-optional and non-array relations do not have the `SetNull` onDelete action
+-   [x] Make sure non-optional and non-array relations do not have the `SetNull` onDelete action on model compilation
+-   [x] Complete update action
+-   [x] Redo Mutation type. It should provide structurally no change:
+    -   [x] Split `add` and `update` mutation until completely separate interfaces?
+    -   [x] -Many or -All are only present on `ArrayRelation`'s,
+    -   [x] Cannot use `delete` or `disconnect` on non-nullable (1-1) relations
+-   [x] Add additional functions to the storeInterface
+    -   [x] get([primaryKey], [include/select])
+    -   [x] update([primaryKey], [updateMutation without where])
+-   [x] Error Handling: Instead of needing to type `tx.abort(...)` just use the `throw new ...` syntax and catch the error and automatically abort the transaction. This will require actions to be wrapped in some kind of try-catch block.
 -   [ ] Dump database to different formats:
     -   [ ] JSON
     -   [ ] CSV
-    -   [ ] YAML
--   [ ] Add extra object syntax to "where" object (i.e. `in`/`ne`/`gt`/...)
--   [ ] On bulk add/puts/deletes, only wait for the last IDBRequest object
-    -   [ ] addMany
-    -   [ ] deleteMany
-    -   [ ] findMany
-    -   [ ] updateMany
--   [ ] Convert internal string unions to enums
--   [x] Remove external dependencies
-    -   [x] deep-equal
-    -   [x] type-fest
-    -   [x] uuid
-    -   [x] zod
+-   [ ] Make package to wrap Tanstack query for react application
+-   [ ] Add extra object syntax to "where" clause (i.e. `in`/`ne`/`gt`/...)
+-   [ ] Allow object types in where clauses
+-   [x] Convert internal string unions to enums
 -   [ ] Make subpackages for adapters for different validation languages
-    -   [ ] Zod
+    -   [x] Zod
     -   [ ] Yup
     -   [ ] Joi
     -   [ ] schema.js
+-   [ ] Migrate to vite instead of rollup
 
 ### Roadmap - Maybe
 
+-   [ ] Optimize batch `add` editing with cursor functionality
 -   [ ] Discriminated union models: Be able to differentiate subtypes of a model by a discriminator key
--   [ ] Error Handling: Instead of needing to type `tx.abort(...)` just use the `throw new ...` syntax and catch the error and automatically abort the transaction. This will require actions to be wrapped in some kind of try-catch block.

package/package.json

@@ -1,15 +1,15 @@
 {
     "name": "@idb-orm/core",
-    "version": "1.0.7",
+    "version": "1.0.8",
     "description": "",
-    "main": "dist/index.js",
+    "main": "./dist/index.js",
     "types": "./dist/index.d.ts",
     "type": "module",
     "scripts": {
-        "build": "rollup --config rollup.config.ts --configPlugin typescript",
-        "watch": "rollup --watch --config rollup.config.ts --configPlugin typescript",
+        "build": "vite build",
+        "watch": "vite build --watch",
         "check": "eslint . && tsc -b --noEmit",
-        "test": "playwright test"
+        "b": "vite build"
     },
     "keywords": [
         "typescript",
@@ -19,18 +19,14 @@
     "exports": {
         ".": {
             "types": "./dist/index.d.ts",
-            "import": "./dist/index.js",
-            "require": "./dist/index.js"
-        },
-        "./dev": {
-            "types": "./dist/dev.d.ts",
-            "default": "./dist/dev.d.ts"
+            "import": "./dist/index.es.js",
+            "require": "./dist/index.cjs.js"
         }
     },
     "license": "ISC",
     "devDependencies": {
         "@eslint/js": "^9.38.0",
-        "@playwright/test": "^1.56.1",
+        "@rolldown/binding-win32-x64-msvc": "^1.0.0-beta.51",
         "@rollup/plugin-node-resolve": "^16.0.3",
         "@rollup/plugin-terser": "^0.4.4",
         "@rollup/plugin-typescript": "^12.1.4",
@@ -38,8 +34,11 @@
         "eslint": "^9.38.0",
         "rollup": "^4.52.4",
         "serve": "^14.2.5",
+        "terser": "^5.44.1",
         "tslib": "^2.8.1",
         "typescript": "^5.9.3",
-        "typescript-eslint": "^8.46.2"
+        "typescript-eslint": "^8.46.2",
+        "vite": "^7.2.4",
+        "vite-plugin-dts": "^4.5.4"
     }
 }

package/dist/builder.d.ts

@@ -1,25 +0,0 @@
-import { CollectionSchema, Model } from "./model";
-import { DbClient } from "./client";
-import { PrimaryKey, type ValidValue } from "./field";
-import type { Dict } from "./util-types";
-export type CollectionObject<Names extends string> = {
-    [K in Names]: Model<K, any>;
-};
-export declare class Builder<Name extends string, Names extends string> {
-    readonly name: Name;
-    readonly names: Names[];
-    private models;
-    constructor(name: Name, names: Names[]);
-    defineModel<N extends Names, T extends Dict<ValidValue<Names>>>(name: N, values: T): Model<N, T, Extract<{ [K in keyof T]: T[K] extends PrimaryKey<any, any> ? K : never; }[keyof T], string>>;
-    compile<M extends CollectionObject<Names>>(models: M): CompiledDb<Name, Names, M>;
-}
-export declare class CompiledDb<Name extends string, Names extends string, C extends CollectionObject<Names>> {
-    readonly name: Name;
-    private readonly models;
-    readonly schemas: CollectionSchema<C>;
-    private readonly modelKeys;
-    constructor(name: Name, models: C);
-    getModel<N extends Names>(name: N): C[N];
-    createClient(version?: number): Promise<DbClient<Name, Names, C>>;
-    keys(): Names[];
-}

package/dist/client/compiled-query.d.ts

@@ -1,13 +0,0 @@
-import type { CollectionObject } from "../builder.ts";
-import type { DbClient } from "./index.ts";
-import type { FindInput, FindOutput } from "./types/find.ts";
-export declare class CompiledQuery<Stores extends string, Models extends CollectionObject<string>, Db extends DbClient<string, Stores, Models>, Input extends FindInput<Stores, Models[Stores], Models> = FindInput<Stores, Models[Stores], Models>, Output = FindOutput<Stores, Models[Stores], Models, Input>> {
-    private readonly client;
-    private readonly name;
-    private readonly accessedStores;
-    private readonly selectClause;
-    constructor(client: Db, name: Stores, input: Input);
-    find(): Promise<Output[]>;
-    findFirst(): Promise<Output>;
-    private _find;
-}

package/dist/client/delete.d.ts

@@ -1,14 +0,0 @@
-import { CollectionObject } from "../builder.js";
-import { ExtractFields } from "../model/model-types.js";
-import { WhereObject } from "./types/find.js";
-import { MutationState } from "./types";
-import { DbClient } from "./index.js";
-/**
- * Deletes document(s) from a store
- * @param name Name of the store
- * @param client DbClient object
- * @param stopOnFirst Stop after the first deletion
- * @param _state Optional state for multi-stage actions
- * @returns Number of items removed
- */
-export declare function deleteItems<ModelNames extends string, Name extends ModelNames, Models extends CollectionObject<ModelNames>>(name: Name, client: DbClient<string, ModelNames, Models>, where?: WhereObject<ExtractFields<Models[Name]>>, stopOnFirst?: boolean, _state?: MutationState<ModelNames>): Promise<number>;

package/dist/client/helpers.d.ts

@@ -1,10 +0,0 @@
-import type { Dict, Promisable } from "../util-types.js";
-import type { DbClient } from "./index.ts";
-import type { CollectionObject } from "../builder.ts";
-import type { QueryInput } from "./types/find.ts";
-import type { Transaction } from "../transaction.js";
-export declare function generateWhereClause(where?: Dict): (obj: unknown) => boolean;
-export declare function generateSelector<ModelNames extends string, Models extends CollectionObject<ModelNames>, Db extends DbClient<string, ModelNames, Models>, Q extends QueryInput<ModelNames, any, Models> = QueryInput<ModelNames, any, Models>>(name: ModelNames, client: Db, query?: Q, initTx?: Transaction<IDBTransactionMode, ModelNames>): (item: Dict, tx: Transaction<IDBTransactionMode, ModelNames>) => Promisable<Dict | undefined>;
-export declare function getAccessedStores<ModelNames extends string, Models extends CollectionObject<ModelNames>>(name: ModelNames, query: Dict, type: "mutation" | "query", client: DbClient<string, ModelNames, Models>): Set<ModelNames>;
-export declare function getSearchableQuery(q: QueryInput<any, any, any>): import("./types/find.ts").SelectObject<any, any, any>;
-export declare function promiseCatch(tx: Transaction<IDBTransactionMode, string>): (error: any) => never;

package/dist/client/index.d.ts

@@ -1,33 +0,0 @@
-import type { CollectionObject, CompiledDb } from "../builder";
-import type { Arrayable } from "../util-types";
-import { Transaction, type TransactionOptions } from "../transaction";
-import { type InterfaceMap } from "./types";
-export declare class DbClient<Name extends string, ModelNames extends string, Models extends CollectionObject<ModelNames>> {
-    private readonly db;
-    private readonly models;
-    readonly name: Name;
-    readonly version: number;
-    readonly stores: InterfaceMap<ModelNames, Models>;
-    constructor(db: IDBDatabase, models: CompiledDb<Name, ModelNames, Models>);
-    getStore<Name extends ModelNames>(name: Name): (typeof this.stores)[Name];
-    createTransaction<Mode extends IDBTransactionMode, Names extends ModelNames>(mode: Mode, stores: Arrayable<Names>, options?: TransactionOptions): Transaction<Mode, Names>;
-    deleteDb(): Promise<void>;
-    deleteAllStores(): void;
-    deleteStore(storeNames: Arrayable<ModelNames>): void;
-    getModel<N extends ModelNames>(name: N): Models[N];
-    private getAccessedStores;
-    private createInterface;
-    private add;
-    private clear;
-    /**
-     * Finds documents from the store that match the filter
-     * @param name Name of the store
-     * @param item Object containing the filter and the selection query
-     * @param stopOnFirst Flag to stop after one successful find
-     * @param _state Optional state for mutli-stage actions
-     * @returns Transformed selection item
-     */
-    private find;
-    private update;
-    private updateSingleton;
-}

package/dist/client/types/find.d.ts

@@ -1,27 +0,0 @@
-import type { Dict, If, Keyof, RemoveNeverValues } from "../../util-types.js";
-import type { ExtractFields, ModelStructure, RelationlessModelStructure } from "../../model/model-types.js";
-import type { Model } from "../../model";
-import type { BaseRelation, AbstractProperty, PrimaryKey, RelationOutputStructure, ValidValue } from "../../field";
-import type { CollectionObject } from "../../builder.ts";
-export type FilterFn<Input> = (item: Input) => boolean;
-/**
- * If an property is an object type (dictionary, array, map, set, etc...) return never. If it's a union it strips out any object types
- */
-export type ProhibitObjects<T> = T extends object ? never : T;
-export type WhereObject<Fields extends Dict<ValidValue>> = Partial<RemoveNeverValues<{
-    [K in keyof Fields]: Fields[K] extends AbstractProperty<infer Output, any> ? Output | FilterFn<Output> : Fields[K] extends PrimaryKey<any, infer Type> ? ProhibitObjects<Type> | FilterFn<Type> : never;
-}>>;
-export type SelectObject<All extends string, Fields extends Dict<ValidValue>, C extends CollectionObject<All>> = {
-    [K in keyof Fields]?: Fields[K] extends AbstractProperty<any, any> ? true : Fields[K] extends PrimaryKey<any, any> ? true : Fields[K] extends BaseRelation<infer To, any> ? true | (To extends Keyof<C> ? C[To] extends Model<any, infer SubFields, any> ? QueryInput<All, SubFields, C> : never : never) : never;
-};
-export interface QueryInput<All extends string, Fields extends Dict<ValidValue>, C extends CollectionObject<All>> {
-    where?: WhereObject<Fields>;
-    select?: SelectObject<All, Fields, C>;
-    include?: SelectObject<All, Fields, C>;
-}
-export type FindInput<All extends string, Struct extends object, C extends CollectionObject<All>> = Struct extends Model<any, infer Fields, any> ? QueryInput<All, Fields, C> : never;
-type _FindOutput<All extends string, Select extends Dict<Dict | true>, Fields extends Dict<ValidValue>, C extends CollectionObject<All>> = {
-    [K in Keyof<Select>]: Fields[K] extends BaseRelation<infer To, any> ? To extends Keyof<C> ? C[To] extends Model<any, infer Sub, any> ? If<Select[K] extends true ? true : false, RelationOutputStructure<Fields[K], RelationlessModelStructure<C[To]>>, Select[K] extends Dict<Dict | true> ? RelationOutputStructure<Fields[K], _FindOutput<All, Select[K], Sub, C>> : never> : never : never : Fields[K] extends PrimaryKey<any, infer Type> ? Type : Fields[K] extends AbstractProperty<infer Type, any> ? Type : never;
-} | undefined;
-export type FindOutput<All extends string, Struct extends Model<any, any, any>, C extends CollectionObject<All>, F extends FindInput<All, Struct, C>> = Struct extends Model<any, infer Fields, any> ? F extends object ? (F["select"] extends Dict<true | Dict> ? _FindOutput<All, F["select"], Fields, C> : ModelStructure<ExtractFields<Struct>, C>) | undefined : never : never;
-export {};

package/dist/client/types/index.d.ts

@@ -1,62 +0,0 @@
-import type { CollectionObject } from "../../builder.ts";
-import type { Dict, ValidKey } from "../../util-types.js";
-import type { ExtractFields, Model, ModelStructure, PrimaryKeyType } from "../../model";
-import type { AddMutation, UpdateMutation } from "./mutation.ts";
-import type { FindInput, FindOutput, WhereObject } from "./find.ts";
-import type { CompiledQuery } from "../compiled-query.ts";
-import type { DbClient } from "../index.ts";
-import { Transaction } from "../../transaction.js";
-import { BaseRelation } from "../../field";
-export type InsertMutation<N extends string, C extends Dict> = C[N] extends Model<N, infer F, any> ? ModelStructure<F, C> : never;
-export interface StoreInterface<Name extends Names, Names extends string, C extends CollectionObject<Names>, KeyType = PrimaryKeyType<C[Name]>, Add = AddMutation<Name, Names, C[Name], C>, Update = UpdateMutation<Name, Names, C[Name], C>> {
-    add(mutation: Add, transaction?: Transaction<"readwrite", Names>): Promise<KeyType>;
-    addMany(mutations: Add[], transaction?: Transaction<"readwrite", Names>): Promise<KeyType[]>;
-    find<T extends FindInput<Names, C[Name], C>>(query: T, transaction?: Transaction<IDBTransactionMode, Names>): Promise<FindOutput<Names, C[Name], C, T>[]>;
-    findFirst<T extends FindInput<Names, C[Name], C>>(query: T, transaction?: Transaction<IDBTransactionMode, Names>): Promise<FindOutput<Names, C[Name], C, T>>;
-    put(): Promise<void>;
-    insert(item: InsertMutation<Name, C>, transaction?: Transaction<"readwrite", Names>): Promise<KeyType>;
-    updateFirst(item: Update, transaction?: Transaction<"readwrite", Names>): Promise<KeyType | undefined>;
-    updateMany(item: Update, transaction?: Transaction<"readwrite", Names>): Promise<KeyType[]>;
-    delete(key: KeyType): Promise<boolean>;
-    deleteFirst(where?: WhereObject<ExtractFields<C[Name]>>): Promise<boolean>;
-    deleteMany(where: WhereObject<ExtractFields<C[Name]>>): Promise<number>;
-    /**
-     * Clears a store (does not update any relations)
-     */
-    clear(transaction?: Transaction<"readwrite", Names>): Promise<void>;
-    compileQuery<T extends FindInput<Names, C[Name], C>>(query: T): CompiledQuery<Names, C, DbClient<string, Names, C>, T>;
-    get(key: KeyType): Promise<any>;
-}
-export type InterfaceMap<Names extends string, C extends CollectionObject<Names>> = {
-    [K in Names]: StoreInterface<K, Names, C>;
-};
-export interface QueryState<Names extends string> {
-    tx?: Transaction<IDBTransactionMode, Names>;
-}
-export declare const enum MutationBreath {
-    Find = 0,
-    Singleton = 1
-}
-export interface MutationState<Names extends string> extends Partial<{
-    tx: Transaction<"readwrite", Names>;
-    relation: {
-        id: ValidKey;
-        key: string;
-    };
-    singleton: {
-        id: ValidKey;
-    };
-    finalStep: boolean;
-}> {
-}
-export type KeyObject<Index = string> = {
-    isFun: boolean;
-    key: Index;
-} & ({
-    isRelation: true;
-    relation: BaseRelation<any, any>;
-} | {
-    isRelation: false;
-    relation?: undefined;
-});
-export type { AddMutation, UpdateMutation };

package/dist/client/types/mutation.d.ts

@@ -1,46 +0,0 @@
-import type { MakeArrayable, MakeOptional, RemoveNeverValues, PartialOnUndefined } from "../../util-types.js";
-import type { BaseRelation, AbstractProperty, OptionalRelation, PrimaryKey, ArrayRelation } from "../../field";
-import type { CollectionObject } from "../../builder.ts";
-import { WhereObject } from "./find.js";
-import { Model, FindRelationKey, RelationValue } from "../../model";
-export type MutationActions = "$connect" | "$connectMany" | "$create" | "$createMany" | "$update" | "$updateMany" | "$delete" | "$deleteMany" | "$deleteAll" | "$disconnect" | "$disconnectMany" | "$disconnectAll";
-export type Mutation<This extends All, All extends string, Struct extends object, C extends CollectionObject<All>, MutType extends string = "add"> = PartialOnUndefined<RemoveNeverValues<Struct extends Model<any, infer Fields, any> ? {
-    [K in keyof Fields]: Fields[K] extends AbstractProperty<infer Type, infer HasDefault> ? MutType extends "update" ? Type | undefined | ((value: Type) => Type) : HasDefault extends true ? Type | undefined : Type : Fields[K] extends PrimaryKey<infer IsAuto, infer Type> ? MutType extends "update" ? never : IsAuto extends true ? never : Type : Fields[K] extends BaseRelation<infer To, infer Name> ? To extends All ? MakeOptional<Fields[K] extends OptionalRelation<any, any> ? true : Fields[K] extends ArrayRelation<any, any> ? true : MutType extends "update" ? true : false, MakeArrayable<Fields[K] extends ArrayRelation<any, any> ? true : false, {
-        $connect: RelationValue<To, C>;
-    } | {
-        $create: Omit<Mutation<To, All, C[To], C, "add">, FindRelationKey<This, Name, C[To]>>;
-    } | (MutType extends "update" ? {
-        $update: Fields[K] extends ArrayRelation<any, any> ? {
-            where?: WhereSelection<C[To]>;
-            data: Mutation<To, All, C[To], C, MutType>;
-        } : Mutation<To, All, C[To], C, MutType>;
-    } | {
-        $delete: Fields[K] extends ArrayRelation<any, any> ? RelationValue<To, C> : true;
-    } | {
-        $disconnect: Fields[K] extends ArrayRelation<any, any> ? RelationValue<To, C> : true;
-    } : never)> | (Fields[K] extends ArrayRelation<any, any> ? {
-        $connectMany: RelationValue<To, C>[];
-    } | {
-        $createMany: Omit<Mutation<To, All, C[To], C, "add">, FindRelationKey<This, Name, C[To]>>[];
-    } | {
-        $updateMany: {
-            where?: WhereSelection<C[To]>;
-            data: Mutation<To, All, C[To], C, MutType>;
-        }[];
-    } | {
-        $deleteMany: RelationValue<To, C>[];
-    } | {
-        $deleteAll: true;
-    } | {
-        $disconnectMany: RelationValue<To, C>[];
-    } | {
-        $disconnectAll: true;
-    } : never)> : never : never;
-} : never>>;
-export type AddMutation<This extends All, All extends string, Struct extends object, C extends CollectionObject<All>> = Mutation<This, All, Struct, C, "add">;
-export interface UpdateMutation<This extends All, All extends string, Struct extends object, C extends CollectionObject<All>> {
-    where?: WhereSelection<Struct>;
-    data: Mutation<This, All, Struct, C, "update">;
-}
-type WhereSelection<Struct extends object> = Struct extends Model<any, infer Fields, any> ? WhereObject<Fields> : never;
-export {};

package/dist/dev-types.d.ts

@@ -1,4 +0,0 @@
-import { ParseFn, AbstractProperty, PropertyOptions } from "./field/property.js";
-import * as util from "./util-types.js";
-import { Type } from "./utils.js";
-export { ParseFn, AbstractProperty, util, PropertyOptions, Type };

package/dist/dev.d.ts

@@ -1,5 +0,0 @@
-import { ParseFn, AbstractProperty, PropertyOptions, PropertyInputOptions } from "./field/property.js";
-import { PropertyUnion } from "./field/field-types.js";
-import * as util from "./util-types.js";
-import { Type } from "./utils.js";
-export { ParseFn, AbstractProperty, util, PropertyOptions, Type, PropertyInputOptions, PropertyUnion, };

package/dist/error.d.ts

@@ -1,194 +0,0 @@
-export type ErrorType = "ID_EXISTS" | "INVALID_ITEM" | "ADD_FAILED" | "UPDATE_FAILED" | "DELETE_FAILED" | "OVERWRITE_RELATION" | "NOT_FOUND" | "GET_FAILED"
-/**
- * The given transaction is invalid for the store it is trying to access
- */
- | "INVALID_TX"
-/**
- * The database is not found
- */
- | "NO_DB" | "CUSTOM" | "INVALID_CONFIG" | "ASSERTION_FAILED" | "OPEN_CURSOR" | "UNKNOWN";
-export declare class StoreError extends Error {
-    readonly code: ErrorType;
-    readonly message: string;
-    constructor(code: ErrorType, message: string);
-}
-export declare const InvalidConfigError: {
-    new (message?: string): {
-        readonly code: ErrorType;
-        readonly message: string;
-        name: string;
-        stack?: string;
-        cause?: unknown;
-    };
-    readonly code: "INVALID_CONFIG";
-    of(message: string): void;
-    isError(error: unknown): error is Error;
-    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
-    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
-    stackTraceLimit: number;
-};
-export declare const InvalidTransactionError: {
-    new (message?: string): {
-        readonly code: ErrorType;
-        readonly message: string;
-        name: string;
-        stack?: string;
-        cause?: unknown;
-    };
-    readonly code: "INVALID_TX";
-    of(message: string): void;
-    isError(error: unknown): error is Error;
-    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
-    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
-    stackTraceLimit: number;
-};
-export declare const InvalidItemError: {
-    new (message?: string): {
-        readonly code: ErrorType;
-        readonly message: string;
-        name: string;
-        stack?: string;
-        cause?: unknown;
-    };
-    readonly code: "INVALID_ITEM";
-    of(message: string): void;
-    isError(error: unknown): error is Error;
-    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
-    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
-    stackTraceLimit: number;
-};
-export declare const AssertionError: {
-    new (message?: string): {
-        readonly code: ErrorType;
-        readonly message: string;
-        name: string;
-        stack?: string;
-        cause?: unknown;
-    };
-    readonly code: "ASSERTION_FAILED";
-    of(message: string): void;
-    isError(error: unknown): error is Error;
-    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
-    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
-    stackTraceLimit: number;
-};
-export declare const UnknownError: {
-    new (message?: string): {
-        readonly code: ErrorType;
-        readonly message: string;
-        name: string;
-        stack?: string;
-        cause?: unknown;
-    };
-    readonly code: "UNKNOWN";
-    of(message: string): void;
-    isError(error: unknown): error is Error;
-    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
-    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
-    stackTraceLimit: number;
-};
-export declare const DeleteError: {
-    new (message?: string): {
-        readonly code: ErrorType;
-        readonly message: string;
-        name: string;
-        stack?: string;
-        cause?: unknown;
-    };
-    readonly code: "DELETE_FAILED";
-    of(message: string): void;
-    isError(error: unknown): error is Error;
-    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
-    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
-    stackTraceLimit: number;
-};
-export declare const ObjectStoreNotFoundError: {
-    new (message?: string): {
-        readonly code: ErrorType;
-        readonly message: string;
-        name: string;
-        stack?: string;
-        cause?: unknown;
-    };
-    readonly code: "NOT_FOUND";
-    of(message: string): void;
-    isError(error: unknown): error is Error;
-    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
-    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
-    stackTraceLimit: number;
-};
-export declare const DocumentNotFoundError: {
-    new (message?: string): {
-        readonly code: ErrorType;
-        readonly message: string;
-        name: string;
-        stack?: string;
-        cause?: unknown;
-    };
-    readonly code: "NOT_FOUND";
-    of(message: string): void;
-    isError(error: unknown): error is Error;
-    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
-    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
-    stackTraceLimit: number;
-};
-export declare const UpdateError: {
-    new (message?: string): {
-        readonly code: ErrorType;
-        readonly message: string;
-        name: string;
-        stack?: string;
-        cause?: unknown;
-    };
-    readonly code: "UPDATE_FAILED";
-    of(message: string): void;
-    isError(error: unknown): error is Error;
-    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
-    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
-    stackTraceLimit: number;
-};
-export declare const AddError: {
-    new (message?: string): {
-        readonly code: ErrorType;
-        readonly message: string;
-        name: string;
-        stack?: string;
-        cause?: unknown;
-    };
-    readonly code: "ADD_FAILED";
-    of(message: string): void;
-    isError(error: unknown): error is Error;
-    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
-    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
-    stackTraceLimit: number;
-};
-export declare const OpenCursorError: {
-    new (message?: string): {
-        readonly code: ErrorType;
-        readonly message: string;
-        name: string;
-        stack?: string;
-        cause?: unknown;
-    };
-    readonly code: "OPEN_CURSOR";
-    of(message: string): void;
-    isError(error: unknown): error is Error;
-    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
-    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
-    stackTraceLimit: number;
-};
-export declare const RetrievalError: {
-    new (message?: string): {
-        readonly code: ErrorType;
-        readonly message: string;
-        name: string;
-        stack?: string;
-        cause?: unknown;
-    };
-    readonly code: "GET_FAILED";
-    of(message: string): void;
-    isError(error: unknown): error is Error;
-    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
-    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
-    stackTraceLimit: number;
-};

package/dist/field/constants.d.ts

@@ -1,9 +0,0 @@
-import z from "zod";
-export declare const DEFAULT_SCHEMA_MAP: {
-    string: z.ZodString;
-    boolean: z.ZodBoolean;
-    number: z.ZodNumber;
-    array: z.ZodArray<z.ZodAny>;
-    object: z.ZodObject<{}, z.core.$loose>;
-    date: z.ZodDate;
-};

package/dist/field/field-types.d.ts

@@ -1,36 +0,0 @@
-import { Dict, ValidKey, ValidKeyType } from "../util-types.js";
-import PrimaryKey from "./primary-key.js";
-import { AbstractProperty, ParseFn, Property } from "./property.js";
-import { BaseRelation, OptionalRelation, ArrayRelation } from "./relation.js";
-export type ReferenceActions = "Cascade" | "None" | "Restrict";
-export type OptionalActions = "SetNull" | ReferenceActions;
-export interface RelationOptions<Name extends string, OnDelete> {
-    name?: Name;
-    onDelete?: OnDelete;
-}
-export interface RelationActions {
-    onDelete: OptionalActions;
-}
-export declare const enum FieldTypes {
-    Field = 0,
-    Relation = 1,
-    PrimaryKey = 2,
-    Invalid = 3
-}
-export type GenFunction<T extends ValidKey> = () => T;
-export type FunctionMatch<E> = E extends "string" ? string : E extends "number" ? number : E extends "date" ? Date : never;
-export type GetPrimaryKeyType<T> = T extends PrimaryKey<any, infer Type> ? Type : never;
-export interface FieldOptions {
-    unique: boolean;
-}
-export type RelationOutput<T> = T extends PrimaryKey<any, infer Type> ? Type : never;
-export type RelationOutputStructure<R extends BaseRelation<any, any>, Output> = R extends ArrayRelation<any, any> ? Output[] : R extends OptionalRelation<any, any> ? Output | undefined : Output;
-export type NonRelationOutput<T> = T extends AbstractProperty<infer Out, any> ? Out : T extends PrimaryKey<any, infer Type> ? Type : never;
-export type ValidValue<N extends string = string> = BaseRelation<N, string> | AbstractProperty<any, any> | PrimaryKey<boolean, ValidKey>;
-export type ParseFnWrap<T extends Dict> = {
-    [K in keyof T]: ParseFn<T[K]>;
-};
-export type PropertyUnion<T extends readonly (Property<any, boolean> | ParseFn<any>)[]> = T[number] extends Property<infer Type, boolean> ? Type : T extends ParseFn<infer Type> ? Type : never;
-export declare const VALIDATORS: {
-    [K in ValidKeyType]: ParseFn<FunctionMatch<K>>;
-};

package/dist/field/field.d.ts

@@ -1,40 +0,0 @@
-import z from "zod";
-import type { ValidKeyType } from "../types/common.js";
-import type { FieldOptions, FunctionMatch, ReferenceActions, RelationOptions } from "./field-types.js";
-import PrimaryKey from "./primary-key.js";
-import { Relation } from "./relation.js";
-export declare class Field<OutputType, HasDefault extends boolean = false> {
-    schema: z.ZodType<OutputType>;
-    private hasDefault;
-    static readonly schemas: {
-        string: z.ZodString;
-        boolean: z.ZodBoolean;
-        number: z.ZodNumber;
-        array: z.ZodArray<z.ZodAny>;
-        object: z.ZodObject<{}, z.core.$loose>;
-        date: z.ZodDate;
-    };
-    private options;
-    constructor(schema: z.ZodType<OutputType>, options?: Partial<FieldOptions>);
-    array(): Field<OutputType[], false>;
-    optional(): Field<OutputType | undefined, false>;
-    default(defaultValue: Exclude<OutputType, undefined>): Field<Exclude<OutputType, undefined>, true>;
-    refine(refineFn: (val: OutputType) => boolean): void;
-    parse(value: unknown): z.ZodSafeParseResult<OutputType>;
-    hasDefaultValue(): HasDefault;
-    /**
-     * Indicates that a field must be unique across all documents
-     *
-     * **NOTE**: The field type must be a primitive. If this is applied to a non-primitive, it returns `null`
-     */
-    unique(): OutputType extends string | number | boolean | symbol ? this : null;
-    static array<T>(item: z.ZodType<T> | Field<T>, options?: FieldOptions): Field<T[], false>;
-    static boolean(schema?: z.ZodType<boolean>, options?: FieldOptions): Field<boolean, false>;
-    static custom<T>(schema: z.ZodType<T>, options?: FieldOptions): Field<T, false>;
-    static object<T extends Record<string, z.ZodType>>(item: T, options?: FieldOptions): Field<z.core.$InferObjectOutput<{ -readonly [P in keyof T]: T[P]; }, {}>, false>;
-    static primaryKey<V extends ValidKeyType = "number">(type?: V): PrimaryKey<false, FunctionMatch<V>>;
-    static literal<V extends string | number | boolean>(value: V): Field<V, false>;
-    static number(schema?: z.ZodType<number>, options?: FieldOptions): Field<number, false>;
-    static string(schema?: z.ZodType<string>, options?: FieldOptions): Field<string, false>;
-    static relation<To extends string, Name extends string = never>(to: To, options?: RelationOptions<Name, ReferenceActions>): Relation<To, Name>;
-}

package/dist/field/index.d.ts

@@ -1,5 +0,0 @@
-import PrimaryKey from "./primary-key.js";
-export { PrimaryKey };
-export * from "./relation.js";
-export * from "./field-types.js";
-export * from "./property.js";

package/dist/field/primary-key.d.ts

@@ -1,20 +0,0 @@
-import { ValidKey, ValidKeyType } from "../util-types.js";
-import { GenFunction } from "./field-types.js";
-export default class PrimaryKey<AutoGenerate extends boolean, Type extends ValidKey> {
-    private genFn?;
-    private autoGenerate;
-    readonly type: ValidKeyType;
-    constructor();
-    constructor(type: ValidKeyType);
-    constructor(type: ValidKeyType, generator: GenFunction<Type>);
-    autoIncrement(): PrimaryKey<true, number>;
-    generator(genFn: GenFunction<Type>): PrimaryKey<true, Type>;
-    uuid(): PrimaryKey<true, string>;
-    genKey(): Type;
-    getSchema(): import("./property.js").ParseFn<string> | import("./property.js").ParseFn<number> | import("./property.js").ParseFn<Date>;
-    /**
-     * If the internal objectStore "autoIncrement" utility is being used
-     * @returns
-     */
-    isAutoIncremented(): boolean;
-}

package/dist/field/property.d.ts

@@ -1,69 +0,0 @@
-import { Literable, NoUndefined, ValidKeyType } from "../util-types.js";
-import { Type } from "../utils.js";
-import { FunctionMatch, PropertyUnion, ReferenceActions, RelationOptions } from "./field-types.js";
-import PrimaryKey from "./primary-key.js";
-import { Relation } from "./relation.js";
-export interface PropertyOptions {
-    unique: boolean;
-}
-export type PropertyInputOptions = Partial<PropertyOptions>;
-export type ParseResult<T> = {
-    success: true;
-    data: T;
-    error?: undefined;
-} | {
-    success: false;
-    data?: undefined;
-    error: string;
-};
-/**
- * A function to parse and validateFn an unknown value. It should also handle applying defaults
- */
-export type ParseFn<T> = (value: unknown) => ParseResult<T>;
-export declare abstract class AbstractProperty<Value, HasDefault extends boolean> {
-    protected validateFn: (value: unknown) => ParseResult<Value>;
-    protected type: Type;
-    protected hasDefault: HasDefault;
-    protected options: PropertyOptions;
-    constructor(validateFn: (value: unknown) => ParseResult<Value>, type: Type, options?: PropertyInputOptions);
-    get validate(): (value: unknown) => ParseResult<Value>;
-    abstract array(...args: unknown[]): AbstractProperty<Value[], false>;
-    abstract optional(...args: unknown[]): AbstractProperty<Value | undefined, false>;
-    abstract default(defaultValue: NoUndefined<Value>): AbstractProperty<NoUndefined<Value>, true>;
-    static array<T>(..._args: unknown[]): AbstractProperty<T[], false>;
-    static literal<const V extends Literable>(_item: V, ..._: unknown[]): AbstractProperty<V, false>;
-    static custom<T>(..._: unknown[]): AbstractProperty<T, false>;
-    static union<const _T extends readonly (ParseFn<any> | AbstractProperty<any, boolean>)[]>(..._: unknown[]): AbstractProperty<unknown, false>;
-    static string(..._: unknown[]): AbstractProperty<string, false>;
-    static number(..._: unknown[]): AbstractProperty<number, false>;
-    static boolean(..._: unknown[]): AbstractProperty<boolean, false>;
-    /**
-     * Indicates that a field must be unique across all documents
-     *
-     * **NOTE**: The field type must be a primitive. If this is applied to a non-primitive, it returns `null`
-     */
-    unique(): Value extends string | number | boolean | symbol ? this : null;
-    hasDefaultValue(): HasDefault;
-    static relation<To extends string, Name extends string = never>(to: To, options?: RelationOptions<Name, ReferenceActions>): Relation<To, Name>;
-    static primaryKey<V extends ValidKeyType = "number">(type?: V): PrimaryKey<false, FunctionMatch<V>>;
-    static readonly validators: {
-        string: ParseFn<string>;
-        number: ParseFn<number>;
-        date: ParseFn<Date>;
-    };
-    protected static literalToType(value: Literable): Type;
-    protected static nameToType(typeName: string): Type;
-}
-export declare class Property<Value, HasDefault extends boolean> extends AbstractProperty<Value, HasDefault> {
-    array(): Property<Value[], false>;
-    default(defaultValue: NoUndefined<Value>): Property<NoUndefined<Value>, true>;
-    optional(): Property<Value | undefined, false>;
-    static literal<const V extends Literable>(value: V, options?: PropertyInputOptions): Property<V, false>;
-    static string(options?: PropertyInputOptions): Property<string, false>;
-    static number(options?: PropertyInputOptions): Property<number, false>;
-    static boolean(options?: PropertyInputOptions): Property<boolean, false>;
-    static union<const T extends readonly (ParseFn<any> | AbstractProperty<any, boolean>)[]>(items: T, options?: PropertyInputOptions): Property<PropertyUnion<T>, false>;
-    static custom<T>(fn: ParseFn<T>, options?: PropertyInputOptions): Property<T, false>;
-    static array<T>(item: ParseFn<T> | Property<T, boolean>, options?: PropertyInputOptions): Property<T[], false>;
-    private static generateArrayValidator;
-}

package/dist/field/relation.d.ts

@@ -1,77 +0,0 @@
-import type { OptionalActions, ReferenceActions, RelationActions, RelationOptions } from "./field-types.js";
-export declare class BaseRelation<To extends string, Name extends string = never> {
-    /**
-     * The name of the model this relation is pointing to
-     */
-    readonly to: To;
-    /**
-     * An optional label to give to the relation. This helps distinguish it from others
-     */
-    readonly name: Name;
-    /**
-     * If the relation is optional or not
-     */
-    readonly isOptional: boolean;
-    /**
-     * If the relation is an array or not
-     */
-    readonly isArray: boolean;
-    /**
-     * Actions to be performed under certain conditions
-     */
-    protected actions: RelationActions;
-    /**
-     * The corresponding relation key on the model this relation points to
-     */
-    private relatedKey;
-    constructor(
-    /**
-     * The name of the model this relation is pointing to
-     */
-    to: To, 
-    /**
-     * An optional label to give to the relation. This helps distinguish it from others
-     */
-    name?: Name, 
-    /**
-     * If the relation is optional or not
-     */
-    isOptional?: boolean, 
-    /**
-     * If the relation is an array or not
-     */
-    isArray?: boolean, onDelete?: OptionalActions);
-    getActions(): {
-        onDelete: OptionalActions;
-    };
-    setRelatedKey(key: string): void;
-    /**
-     * Gets the key on the corresponding model this relation points to
-     */
-    getRelatedKey(): string;
-}
-export declare class Relation<To extends string, Name extends string> extends BaseRelation<To, Name> {
-    private readonly _brand;
-    constructor(to: To, options?: RelationOptions<Name, ReferenceActions>);
-    /**
-     * Creates an array relation to the specified model
-     *
-     * **Note: Calling this function will reset any relation actions to the default**
-     */
-    array({ onDelete, }?: Omit<RelationOptions<Name, OptionalActions>, "name">): ArrayRelation<To, Name>;
-    /**
-     * Creates an optional relation to the specified model
-     *
-     * **Note: Calling this function will reset any relation actions to the default**
-     */
-    optional({ onDelete, }?: Omit<RelationOptions<Name, OptionalActions>, "name">): OptionalRelation<To, Name>;
-    onDelete(action: ReferenceActions): this;
-}
-export declare class ArrayRelation<To extends string, Name extends string> extends BaseRelation<To, Name> {
-    private readonly _brand;
-    constructor(to: To, name?: Name, action?: OptionalActions);
-}
-export declare class OptionalRelation<To extends string, Name extends string> extends BaseRelation<To, Name> {
-    private readonly _brand;
-    constructor(to: To, name?: Name, action?: OptionalActions);
-}

package/dist/index.d.ts

@@ -1,10 +0,0 @@
-import { Builder } from "./builder.js";
-import { StoreError, type ErrorType } from "./error.js";
-import "./dev.js";
-export { Builder, StoreError, ErrorType };
-import { Property } from "./field";
-export { Property };
-import { CompiledQuery } from "./client/compiled-query.js";
-export { CompiledQuery };
-import type { ModelType } from "./model";
-export { ModelType };

package/dist/index.js

@@ -1 +0,0 @@
-class e extends Error{code;message;constructor(e,t){super(),this.code=e,this.message=t}}function t(t,n){return class extends e{static code;constructor(e=n){super(t,e)}static of(e){new this(e)}}}const n=t("INVALID_CONFIG","Configuration is invalid"),s=t("INVALID_TX","Transaction is invalid"),r=t("INVALID_ITEM","Item is invalid"),o=t("ASSERTION_FAILED","Assertion failed"),a=t("UNKNOWN","An unknown error occurred"),i=t("DELETE_FAILED","Item could not be deleted"),c=t("NOT_FOUND","Object Store Not Found"),l=t("NOT_FOUND","Document Not Found"),u=t("UPDATE_FAILED","Item could not be updated"),d=t("ADD_FAILED","Item could not be added"),h=t("OPEN_CURSOR","Cursor could not be opened"),y=t("GET_FAILED","Item could not be retrieved");async function f(e,t){return await new Promise(t=>{e.onsuccess=()=>{t(e.result)},e.onerror=()=>{}})}function w(e){return Object.keys(e)}function m(e){return Array.isArray(e)||(e=[e]),e}function g(e){switch(e){case"date":return A.Date;case"number":return A.Number;case"string":return A.String}}function b(){return crypto.randomUUID()}function p(e){return e}function k(e,t){for(const n of t.keys())e.add(n);return e}var A;!function(e){e[e.String=0]="String",e[e.Number=1]="Number",e[e.BigInt=2]="BigInt",e[e.Boolean=3]="Boolean",e[e.Symbol=4]="Symbol",e[e.Array=5]="Array",e[e.Date=6]="Date",e[e.Object=7]="Object",e[e.Unknown=8]="Unknown"}(A||(A={}));const S={string:e=>"string"==typeof e?{success:!0,data:e}:{success:!1,error:"Value is not a string"},number:e=>"number"==typeof e?{success:!0,data:e}:{success:!1,error:"Value is not a string"},date:e=>e instanceof Date?isNaN(e.getTime())?{success:!1,error:"Value is not a valid date"}:{success:!0,data:e}:{success:!1,error:"Value is not a date"}};class ${genFn;autoGenerate;type;constructor(e,t){e?(this.type=e,t?(this.autoGenerate=!0,this.genFn=t):this.autoGenerate=!1):(this.autoGenerate=!1,this.type="number")}autoIncrement(){if("number"===this.type)return this.genFn=void 0,this.autoGenerate=!0,this;const e=new $;return e.genFn=void 0,e.autoGenerate=!0,e}generator(e){return this.genFn=e,this.autoGenerate=!0,this}uuid(){if(!window.isSecureContext)throw new Error("Window is not in a secure context");return new $("string",b)}genKey(){if(this.genFn)return this.genFn();throw new Error("Generator function not defined")}getSchema(){return S[this.type]}isAutoIncremented(){return this.autoGenerate&&!this.genFn}}class N{to;name;isOptional;isArray;actions;relatedKey;constructor(e,t="",n=!1,s=!1,r){this.to=e,this.name=t,this.isOptional=n,this.isArray=s,this.relatedKey="",this.actions={onDelete:r||"Restrict"}}getActions(){return{...this.actions}}setRelatedKey(e){this.relatedKey=e}getRelatedKey(){return this.relatedKey}}class v extends N{constructor(e,t={}){super(e,t.name,!1,!1,t.onDelete)}array({onDelete:e}={}){return new I(this.to,this.name,e)}optional({onDelete:e}={}){return new K(this.to,this.name,e)}onDelete(e){return this.actions.onDelete=e,this}}class I extends N{constructor(e,t,n="SetNull"){super(e,t,!1,!0,n)}}class K extends N{constructor(e,t,n="SetNull"){super(e,t,!0,!1,n)}}class D{validateFn;type;hasDefault=!1;options;constructor(e,t,n){this.validateFn=e,this.type=t,this.options={unique:n?.unique??!1}}get validate(){return this.validateFn}static array(...e){throw new Error("Method Not Implemented")}static literal(e,...t){throw new Error("Method Not Implemented")}static custom(...e){throw new Error("Method Not Implemented")}static union(...e){throw new Error("Method Not Implemented")}static string(...e){throw new Error("Method Not Implemented")}static number(...e){throw new Error("Method Not Implemented")}static boolean(...e){throw new Error("Method Not Implemented")}unique(){switch(this.type){case A.Boolean:case A.String:case A.Number:case A.Symbol:return this.options.unique=!0,this;default:return console.error("A non-primitive cannot be a unique value"),null}}hasDefaultValue(){return this.hasDefault}static relation(e,t){return new v(e,t)}static primaryKey(e="number"){return new $(e)}static validators=S;static literalToType(e){return D.nameToType(typeof e)}static nameToType(e){switch(e){case"boolean":return A.Boolean;case"bigint":return A.BigInt;case"number":case"string":return A.Number;case"object":return A.Object;case"symbol":return A.Symbol;default:return A.Unknown}}}class M extends D{array(){return new M(M.generateArrayValidator(this.validateFn),A.Array,this.options)}default(e){return this.hasDefault=!0,new M(t=>null==t?{success:!0,data:e}:this.validateFn(t),this.type,this.options)}optional(){return new M(e=>null==e?{success:!0,data:void 0}:this.validateFn(e),this.type,this.options)}static literal(e,t){return new M(t=>t===e?{success:!0,data:e}:{success:!1,error:`${t} !== ${e}`},M.literalToType(e),t)}static string(e){return new M(D.validators.string,A.String,e)}static number(e){return new M(D.validators.number,A.Number,e)}static boolean(e){return new M(e=>"boolean"==typeof e?{success:!0,data:e}:{success:!1,error:"Value is not a string"},A.Boolean,e)}static union(e,t){const n=e.map(e=>e instanceof D?e.validate:e);return new M(e=>{for(const t of n){const n=t(e);if(n.success)return n}return{success:!1,error:"Value did not match any of the items"}},A.Unknown,t)}static custom(e,t){return new M(e,A.Unknown,t)}static array(e,t){return new M(M.generateArrayValidator(e instanceof M?e.validateFn:e),A.Array,t)}static generateArrayValidator(e){return t=>{if(Array.isArray(t)){const n=[];for(const s of t){const t=e(s);if(!t.success)return t;n.push(t.data)}return{success:!0,data:n}}return{success:!1,error:"Value is not an array"}}}}class O{name;fields;fieldKeys;relationLinks=new Set;cache={};primaryKey;constructor(t,n){this.name=t,this.fields=n,this.fieldKeys=w(n);for(const e of this.fieldKeys){const t=this.fields[e];t instanceof N&&t.to!==this.name&&this.relationLinks.add(t.to)}const s=this.fieldKeys.find(e=>this.fields[e]instanceof $);if(!s)throw new e("INVALID_CONFIG",`Model ${this.name} has no primary key`);this.primaryKey=s}get(e){return this.fields[e]}getModelField(e){const t=this.fields[e];if(t&&t instanceof D)return t}getPrimaryKey(){return this.fields[this.primaryKey]}getRelation(e){const t=this.fields[e];if(t&&t instanceof N)return t}keyType(e){const t=this.fields[e];return t?t instanceof D?0:t instanceof N?1:t instanceof $?2:3:3}links(){return this.relationLinks.keys()}keys(){return[...this.fieldKeys]}parseField(e,t){return this.fields[e]instanceof D?this.fields[e].validate(t):null}getDeletedStores(e){if(this.cache.delete)return this.cache.delete;const t=new Set,n=[this.name];let s;for(;n.length>0;){const r=n.shift();if(t.has(r))continue;s=e.getModel(r);const o=s.cache.delete;if(o)k(t,o);else{t.add(r);for(const e of s.links())t.has(e)||n.push(e)}}return this.cache.delete=t,t}}class F{tx;store;constructor(e,t){this.tx=e,this.store=t}async add(e){return await this.handleRequest(this.store.add(e),()=>new d)}async get(e){return await this.handleRequest(this.store.get(e),()=>new y)}async put(e){return await this.handleRequest(this.store.put(e),()=>new u)}async delete(e){return await this.handleRequest(this.store.delete(e),()=>new i)}async openCursor(e,t={}){const n=t.onError||(()=>new h),s=this.store.openCursor(t.query,t.direction);await new Promise(t=>{s.onsuccess=async s=>{if(!s.target)throw this.tx.abort(n());const r=s.target.result;r&&await e(r,this.tx)||t()},s.onerror=()=>{throw this.tx.abort(n())}})}async handleRequest(e,t){return await new Promise(n=>{e.onsuccess=()=>{n(e.result)},e.onerror=()=>{throw this.tx.abort(t())}})}}class x{internal;status;error=null;storeNames;objectStores;constructor(e,t,n,s={}){this.internal=e.transaction(t,n),this.status="running",this.storeNames=Array.from(this.internal.objectStoreNames),this.objectStores={};for(const e of this.storeNames)this.objectStores[e]=this.getObjectstore(e);this.internal.onabort=this.registerHandler("aborted",s.onAbort),this.internal.onerror=this.registerHandler("error",s.onError),this.internal.oncomplete=this.registerHandler("complete",s.onComplete)}abort(e){return this.internal.abort(),this.error=e,this.error}commit(){this.internal.commit()}getInternal(){return this.internal}getStore(e){const t=this.objectStores[e];if(!t)throw this.abort(new s(`Store '${e}' is not a part of this transaction`));return t}get mode(){return this.internal.mode}is(e){return this.status===e}contains(e){Array.isArray(e)||(e=[e]);for(const t of e)if(!this.internal.objectStoreNames.contains(t))return!1;return!0}assertIsArray(e,t="Value is not an array"){if(!Array.isArray(e))throw this.abort(new o(t))}getObjectstore(e){try{return new F(this,this.internal.objectStore(e))}catch{throw this.abort(new c(`No ObjectStore with the name '${e}' found`))}}registerHandler(e,t=()=>{}){return n=>{this.status=e,t(this,n)}}async wrap(t){try{return await t(this)}catch(t){throw t instanceof e&&"aborted"===this.status?t:this.abort(new a)}}}function R(e){if(!e)return()=>!0;const t=[];for(const n in e)if(Object.hasOwn(e,n))switch(typeof e[n]){case"function":t.push([n,e[n]]);break;case"object":break;default:t.push([n,t=>t===e[n]])}return e=>{if(!e||"object"!=typeof e)return!1;for(const n of t)if(!n[1](e[n[0]]))return!1;return!0}}function j(e,t,n={},s){const o=t.getModel(e);if(n.include&&n.select)throw s?s.abort(new r("include and select cannot both be defined")):new r("include and select cannot both be defined");const a=R(n.where),i=n.select?"select":n.include?"include":"";if(i){const e=n[i],r=!!n.select,c=[];for(const n in e)if(Object.hasOwn(e,n)&&e[n])switch(o.keyType(n)){case 1:{const r=o.getRelation(n),a="object"==typeof e[n]?j(r.to,t,e[n],s):p;if(r.isArray){const e=async(e,t)=>{const n=[],s=t.getStore(r.to);for(const r of e){const e=await a(await s.get(r),t);e&&n.push(e)}return n};c.push({key:n,getValue:e})}else{const e=async(e,t)=>await a(await t.getStore(r.to).get(e),t);c.push({key:n,getValue:e})}break}case 0:case 2:r&&c.push({key:n})}return r?async(e,t)=>{if(!a(e))return;const n={};for(const{key:s,getValue:r}of c)n[s]=r?await r(e[s],t):e[s];return n}:async(e,t)=>{if(a(e)){for(const{key:n,getValue:s}of c)e[n]=await s(e[n],t);return e}}}return e=>a(e)?e:void 0}function T(e,t,n,s){const r=new Set([e]);if("mutation"===n){const o=w(t),a=s.getModel(e);for(const e of o){const o=a.getRelation(e),i=m(t[e]);if(o)for(const e of i)if(e&&"object"==typeof e)for(const t in e)if(Object.hasOwn(e,t))switch(t){case"$connect":case"$connectMany":case"$disconnect":case"$disconnectMany":r.add(o.to);break;case"$delete":case"$deleteMany":k(r,a.getDeletedStores(s));break;case"$create":k(r,T(o.to,e[t],n,s));break;case"$createMany":e[t].forEach(e=>k(r,T(o.to,e,n,s)))}}}else{const n=s.getModel(e);for(const e of w(t)){const o=n.getRelation(e);if(o)switch(typeof t[e]){case"object":k(r,T(o.to,E(t[e]),"query",s));break;case"boolean":r.add(o.to)}}}return r}function E(e){return e.include?e.include:e.select?e.select:{}}function C(t){return n=>{throw n instanceof e?t.abort(n):t.abort(new a(String(n)))}}class V{client;name;accessedStores;selectClause;constructor(e,t,n){this.client=e,this.name=t,this.accessedStores=Array.from(T(t,E(n),"query",this.client)),this.selectClause=j(t,this.client,n)}async find(){return await this._find(!1)}async findFirst(){return(await this._find(!0))[0]}async _find(e){const t=this.client.createTransaction("readonly",this.accessedStores),n=[],s=t.getStore(this.name);return await s.openCursor(async s=>{const r=await this.selectClause(s.value,t);return r&&n.push(r),(!e||!n.length)&&(s.continue(),!0)}),n}}async function _(e,t,s,r=!1,o={}){const{singleton:a,finalStep:c=!0}=o,l=t.getModel(e),u=o.tx?o.tx.storeNames:Array.from(l.getDeletedStores(t)),d=o.tx??t.createTransaction("readwrite",u),h=d.getStore(e);let y=0;const w=async s=>{if(!s)return!1;const r=s[l.primaryKey];for(const o of l.links()){const a=l.getRelation(o),{onDelete:c}=a.getActions(),u=s[o],h=t.getModel(a.to);switch(c){case"Cascade":if(a.isArray){d.assertIsArray(u);for(const e of u)await _(a.to,t,void 0,void 0,{tx:d,singleton:{id:e}})}else u&&await _(a.to,t,void 0,void 0,{tx:d,singleton:{id:u}});break;case"SetNull":{if(!u)break;const e=m(u),t=d.getStore(a.to),s=a.getRelatedKey(),o=h.getRelation(s);if(!o)throw d.abort(new n(`Relation '${a.name}' has an invalid relation key '${a.getRelatedKey()}'`));if(!o.isArray&&!o.isOptional)throw d.abort(new n(`Key '${s}' on model '${s}': Non-optional relation cannot have the 'SetNull' action`));for(const n of e){const e=await t.get(n);if(!e)continue;const a=e[s];if(o.isArray){d.assertIsArray(a);const e=a.indexOf(r);if(-1===e)continue;a.splice(e,1)}else e[s]=null;await t.put(e)}break}case"Restrict":if(Array.isArray(u)&&u.length>0||u)throw d.abort(new i(`Key '${o}' on model '${e}' deletion is restricted while there is an active relation`))}}return!0};if(a)await w(await h.get(a.id))&&(await h.delete(a.id),y++);else{const e=R(s);let t;await h.openCursor(async n=>{const s=n.value;return e(s)&&await w(s)&&(t=n.delete()),r&&y>0?(t&&c&&await f(t),!1):(n.continue(),!0)})}return y}class q{db;models;name;version;stores;constructor(e,t){this.db=e,this.models=t,this.name=this.db.name,this.version=this.db.version,this.stores={};for(const e of this.models.keys())this.stores[e]=this.createInterface(e)}getStore(e){return this.stores[e]}createTransaction(e,t,n){return new x(this.db,t,e,n)}async deleteDb(){await f(window.indexedDB.deleteDatabase(this.name))}deleteAllStores(){for(const e of this.models.keys())this.db.deleteObjectStore(e)}deleteStore(e){Array.isArray(e)||(e=[e]);for(const t of e)this.db.deleteObjectStore(t)}getModel(e){return this.models.getModel(e)}getAccessedStores(e,t,n="mutation"){return Array.from(T(e,t,n,this))}createInterface(e){return{add:async(t,n)=>await this.add(e,t,{tx:n}),addMany:async(t,n)=>{if(!n){const s=new Set;for(const n of t)k(s,T(e,n,"mutation",this));n=this.createTransaction("readwrite",Array.from(s))}const s=[];let r;for(const o of t)r=this.add(e,o,{tx:n}),r.then(e=>s.push(e)).catch(C(n));return r&&await r,s},clear:async t=>await this.clear(e,{tx:t}),findFirst:async(t,n)=>(await this.find(e,t,!0,{tx:n}))[0],find:async(t,n)=>await this.find(e,t,!1,{tx:n}),put:async()=>{},get:async t=>{const n=this.createTransaction("readonly",e);return await n.getStore(e).get(t)},insert:async(e,t)=>(await new Promise(e=>e()),5),updateFirst:async(t,n)=>(await this.update(e,t,!0,{tx:n}))[0],updateMany:async(t,n)=>await this.update(e,t,!1,{tx:n}),compileQuery:t=>new V(this,e,t),delete:async t=>await _(e,this,void 0,void 0,{singleton:{id:t}})>0,deleteFirst:async t=>await _(e,this,t,!0)>0,deleteMany:async t=>await _(e,this,t,!1)}}async add(e,t,n={}){let{tx:s}=n;const{relation:o}=n,i=s?s.storeNames:this.getAccessedStores(e,t,"mutation");s=s??new x(this.db,i,"readwrite");const c=s.getStore(e),u=this.getModel(e),d=u.getPrimaryKey(),h=o?{[o.key]:u.getRelation(o.key)?.isArray?[o.id]:o.id}:{},y=d.isAutoIncremented()?{...h}:{...h,[u.primaryKey]:t[u.primaryKey]??d.genKey()},f=await c.add(y),g={},b=new Set;for(const n of w(t)){b.add(n);const o=t[n];switch(u.keyType(n)){case 3:throw s.abort(new r(`Key '${n}' does ont exist on model '${e}'`));case 0:{const e=u.parseField(n,o);if(!e)throw s.abort(new a);if(!e.success)throw s.abort(new r(`Key '${n}' has the following validation error: ${e.error}`));g[n]=e.data;break}case 1:{if(!o)continue;const e=m(o),t=u.getRelation(n);if(t.isArray&&(g[n]=[],"$createMany"in o||"$connectMany"in o)){const t=[];for(const e of o.$createMany??[])t.push({$create:e});for(const e of o.$connectMany??[])t.push({$connect:e});e.push(...t)}const a=this.getModel(t.to).getRelation(t.getRelatedKey()),i=s.getStore(t.to),c=new Set;for(const o of e){const e=w(o)[0];if(!e)throw s.abort(new r(`Key '${n}' cannot be an empty connection object`));switch(e){case"$connect":{const u=o[e];if(c.has(u))throw s.abort(new r(`Primary key '${u}' was already used for a connection`));c.add(u);const d=await i.get(u);if(!d)throw s.abort(new l(`Document with Primary Key '${u}' could not be found in model '${t.to}'`));if(!a)throw s.abort(new r(`Could not find corresponding relation '${t.name}'`));if(a.isArray)d[t.getRelatedKey()].push(f);else{const e=t.getRelatedKey();d[e],d[e]=f}i.put(d).catch(C(s)),t.isArray?g[n].push(u):g[n]=u;break}case"$create":{const r=await this.add(t.to,o[e],{tx:s,relation:{id:f,key:t.getRelatedKey()}});t.isArray?g[n].push(r):g[n]=r;break}case"$connectMany":case"$createMany":break;default:throw s.abort(new r(`Connection Object on key '${n}' has an unknown key '${e}'`))}if(!t.isArray)break}break}}}const p=Array.from(new Set(u.keys()).difference(b));for(const e of p)switch(u.keyType(e)){case 0:{const t=u.parseField(e,void 0);if(!t)throw s.abort(new a);if(!t.success)throw s.abort(new r(`Key '${e}' is missing`));g[e]=t.data;break}case 1:{const t=u.getRelation(e),n=h[e];if(t.isArray)g[e]=n??[];else if(t.isOptional)g[e]=n??null;else{if(!n)throw s.abort(new r(`Required relation '${e}' is not defined`));g[e]=n}break}}return await c.put({[u.primaryKey]:f,...g})}async clear(e,t){await _(e,this,void 0,!1,t)}async find(e,t,n,s={}){let{tx:r}=s;const o=r?r.storeNames:this.getAccessedStores(e,E(t),"query");r=r??new x(this.db,o,"readonly");const a=[],i=r.getStore(e),c=j(e,this,t,r);return await i.openCursor(async e=>{const t=await c(e.value,r);return t&&a.push(t),(!n||!a.length)&&(e.continue(),!0)}),a}async update(e,t,n,s={}){let{tx:o}=s;const{singleton:i=!1}=s,c=o?o.storeNames:this.getAccessedStores(e,t.data,"mutation");o=o??new x(this.db,c,"readwrite");const l=[],d=o.getStore(e),h=this.getModel(e),{where:y,data:f}=t,g=[];for(const e of w(f))switch(h.keyType(e)){case 0:g.push({key:e,isFun:"function"==typeof f[e],isRelation:!1});break;case 1:g.push({key:e,isFun:!1,isRelation:!0,relation:h.getRelation(e)});break;case 2:throw o.abort(new u("Primary key field cannot be updated"));default:throw o.abort(new a(`Unknown key '${e}'`))}const b=R(y),p=async e=>{if(y&&!b(e))return!1;for(const{key:t,isRelation:n,isFun:s,relation:a}of g){if(!n){e[t]=s?f[t](e[t]):f[t];continue}const i=m(f[t]);for(const n of i)for(const s in n){if(!Object.hasOwn(n,t))continue;const i=n[t];switch(s){case"$connect":case"$create":case"$updateMany":case"$delete":case"$disconnect":break;case"$update":a.isArray?await this.update(a.to,i,!0,{tx:o}):e[t]&&await this.updateSingleton(a.to,e[t],i,{tx:o});break;case"$connectMany":case"$createMany":case"$deleteMany":case"$disconnectMany":case"$disconnectAll":case"$deleteAll":throw o.abort(new r(`Connection Object on key '${t}' has an unknown key '${s}'`))}break}}};return i?await p(await d.get(i.id)):await d.openCursor(async e=>(await p(e.value),(!n||!l.length)&&(e.continue(),!0))),l}async updateSingleton(e,t,n,s){let{tx:r}=s;const o=r?r.storeNames:this.getAccessedStores(e,n,"mutation");r=r??new x(this.db,o,"readwrite");const a=r.getStore(e),i=this.getModel(e),c=await a.get(t);if(!c)throw r.abort(new l(`No document with key '${t}' could be found in store '${i.name}'`));return c}}class L{name;names;models;constructor(e,t){this.name=e,this.names=t,this.models={}}defineModel(e,t){const n=new O(e,t);return this.models[e]=n,n}compile(e){return new G(this.name,e)}}class G{name;models;schemas;modelKeys;constructor(t,n){this.name=t,this.models=n,this.modelKeys=w(this.models),this.schemas={};for(const t of this.modelKeys){const n=this.models[t],s={};for(const r of n.keys()){const o=n.get(r);if(o instanceof D)s[r]=o.validate;else if(o instanceof N){const a=this.models[o.to],i=a.getPrimaryKey();s[r]=D.validators[i.type],o.isOptional?s[r]=new M(s[r],g(i.type)).optional().validate:o.isArray&&(s[r]=s[r]=new M(s[r],g(i.type)).array().validate);let c=!!o.getRelatedKey();if(!c)for(const e of a.keys()){const t=a.get(e);if(r!==e&&t instanceof N&&t.to===n.name&&t.name===o.name){c=t.to!==o.to||r!==e,c&&(o.setRelatedKey(e),t.setRelatedKey(r));break}}if(!c)throw new e("INVALID_CONFIG",`Relation '${o.name}' of model ${t} does not have an equivalent relation on model '${o.to}'`)}else{if(!(o instanceof $))throw new e("INVALID_CONFIG",`Unknown field value detected: ${JSON.stringify(o)}`);s[r]=D.validators[o.type]}}this.schemas[t]=s}}getModel(e){return this.models[e]}async createClient(e=1){const t=window.indexedDB.open(this.name,e);t.onupgradeneeded=e=>{const t=e.target.result;for(const e of this.modelKeys){const n=this.models[e];t.objectStoreNames.contains(n.name)||t.createObjectStore(n.name,{autoIncrement:n.getPrimaryKey().isAutoIncremented(),keyPath:n.primaryKey})}};const n=await f(t);return new q(n,this)}keys(){return[...this.modelKeys]}}export{L as Builder,V as CompiledQuery,M as Property,e as StoreError};

package/dist/model/index.d.ts

@@ -1,3 +0,0 @@
-import Model from "./model.js";
-export * from "./model-types.js";
-export { Model };

package/dist/model/model-types.d.ts

@@ -1,38 +0,0 @@
-import { CompiledDb } from "../builder.js";
-import { ValidValue, BaseRelation, OptionalRelation, ArrayRelation, RelationOutput, Relation, AbstractProperty, PrimaryKey, ParseFnWrap } from "../field";
-import { Dict, Keyof } from "../util-types.js";
-import Model from "./model.js";
-export type FindPrimaryKey<F extends Record<string, ValidValue>> = Extract<{
-    [K in keyof F]: F[K] extends PrimaryKey<any, any> ? K : never;
-}[keyof F], string>;
-export type PrimaryKeyType<M extends Model<any, any, any>> = M extends Model<any, infer F, any> ? {
-    [K in keyof F]: F[K] extends PrimaryKey<any, infer Type> ? Type : never;
-}[keyof F] : never;
-export interface ModelCache {
-    delete?: Set<string>;
-}
-/**
- * Gets the type of a relation given its name
- */
-export type RelationValue<Name extends string, C> = Name extends keyof C ? C[Name] extends Model<any, infer Fields, infer PrimaryKey> ? RelationOutput<Fields[PrimaryKey]> : never : never;
-/**
- * Gets the primitive type of the relation field
- */
-export type GetRelationField<F, C> = F extends Relation<infer To, any> ? RelationValue<To, C> : F extends OptionalRelation<infer To, any> ? RelationValue<To, C> | undefined : F extends ArrayRelation<infer To, any> ? RelationValue<To, C>[] : never;
-export type ModelStructure<F extends Dict<ValidValue>, C> = {
-    [K in keyof F]: F[K] extends AbstractProperty<infer Output, any> ? Output : F[K] extends PrimaryKey<any, infer Type> ? Type : GetRelationField<F[K], C>;
-};
-export type ModelType<M extends Model<any, any, any>, C extends CompiledDb<any, any, any>> = M extends Model<any, infer Fields, any> ? C extends CompiledDb<any, any, infer Collection> ? ModelStructure<Fields, Collection> : never : never;
-export type ExtractFields<M extends Model<any, any, any>> = M extends Model<any, infer Fields, any> ? Fields : never;
-export type AllRelationKeys<M extends Model<any, any, any>> = M extends Model<any, infer Fields, any> ? {
-    [K in Keyof<Fields>]: Fields[K] extends BaseRelation<any, any> ? K : never;
-}[Keyof<Fields>] : never;
-export type RelationlessModelStructure<M extends Model<any, any, any>> = M extends Model<any, infer Fields, any> ? Omit<{
-    [K in Keyof<Fields>]: Fields[K] extends BaseRelation<any, any> ? unknown : Fields[K] extends AbstractProperty<infer Type, any> ? Type : Fields[K] extends PrimaryKey<any, infer Type> ? Type : never;
-}, AllRelationKeys<M>> : never;
-export type CollectionSchema<C> = C extends Record<infer Keys, Model<any, any, any>> ? {
-    [K in Keys]: C[K] extends Model<any, infer Fields, any> ? ParseFnWrap<ModelStructure<Fields, C>> : never;
-} : never;
-export type FindRelationKey<From extends string, RelationName extends string, M extends Model<any, any, any>> = M extends Model<any, infer Fields, any> ? {
-    [K in Keyof<Fields>]: Fields[K] extends BaseRelation<From, infer CurName> ? CurName extends RelationName ? K : never : never;
-}[Keyof<Fields>] : never;

package/dist/model/model.d.ts

@@ -1,23 +0,0 @@
-import { CollectionObject } from "../builder.js";
-import { DbClient } from "../client/index.js";
-import { BaseRelation, AbstractProperty, FieldTypes, PrimaryKey, ValidValue, ParseResult } from "../field";
-import { Keyof, ValidKey } from "../util-types.js";
-import { FindPrimaryKey } from "./model-types.js";
-export default class Model<Name extends string, F extends Record<string, ValidValue>, Primary extends FindPrimaryKey<F> = FindPrimaryKey<F>> {
-    readonly name: Name;
-    private readonly fields;
-    private readonly fieldKeys;
-    private readonly relationLinks;
-    private cache;
-    readonly primaryKey: Primary;
-    constructor(name: Name, fields: F);
-    get<K extends Keyof<F>>(key: K): F[K];
-    getModelField(key: string): AbstractProperty<any, any> | undefined;
-    getPrimaryKey(): PrimaryKey<boolean, ValidKey>;
-    getRelation<Models extends string>(key: string): BaseRelation<Models, string> | undefined;
-    keyType(key: Keyof<F>): FieldTypes;
-    links<Names extends string = string>(): SetIterator<Names>;
-    keys(): Keyof<F>[];
-    parseField<K extends Keyof<F>>(field: K, value: unknown): ParseResult<any>;
-    getDeletedStores<ModelNames extends string, Models extends CollectionObject<ModelNames>>(client: DbClient<string, ModelNames, Models>): Set<ModelNames>;
-}

package/dist/object-store.d.ts

@@ -1,26 +0,0 @@
-/**
- * A paper thin wrapper around IDBObjectStore
- */
-import { StoreError } from "./error.js";
-import { Transaction } from "./transaction.js";
-import { Dict, Promisable, ValidKey } from "./util-types.js";
-export declare class ObjectStore {
-    private readonly tx;
-    readonly store: IDBObjectStore;
-    constructor(tx: Transaction<IDBTransactionMode, string>, store: IDBObjectStore);
-    add(item: Dict): Promise<ValidKey>;
-    /**
-     * Attempts to retrieve the value from the object store.
-     *
-     * Returns `undefined` if no value was found
-     */
-    get(key: ValidKey): Promise<Dict>;
-    put(item: Dict): Promise<ValidKey>;
-    delete(key: ValidKey): Promise<undefined>;
-    openCursor(callback: (cursor: IDBCursorWithValue, tx: Transaction<IDBTransactionMode, string>) => Promisable<boolean>, options?: {
-        query?: IDBValidKey | IDBKeyRange;
-        direction?: IDBCursorDirection;
-        onError?: () => StoreError;
-    }): Promise<void>;
-    private handleRequest;
-}

package/dist/transaction.d.ts

@@ -1,39 +0,0 @@
-import { StoreError } from "./error";
-import { ObjectStore } from "./object-store.js";
-import { Arrayable } from "./util-types.js";
-export type TransactionStatus = "running" | "aborted" | "complete" | "error";
-export type TransactionEventHandler = (tx: Transaction<IDBTransactionMode>, ev: Event) => void;
-export interface TransactionOptions extends Partial<{
-    onAbort: TransactionEventHandler;
-    onError: TransactionEventHandler;
-    onComplete: TransactionEventHandler;
-}> {
-}
-export declare class Transaction<Mode extends IDBTransactionMode, Stores extends string = string> {
-    private internal;
-    status: TransactionStatus;
-    error: StoreError | null;
-    readonly storeNames: Stores[];
-    /**
-     * A record of store names to `IDBObjectStore` objects
-     */
-    private readonly objectStores;
-    constructor(db: IDBDatabase, stores: Arrayable<Stores>, mode: Mode, options?: TransactionOptions);
-    abort(error: StoreError): StoreError;
-    commit(): void;
-    /**
-     * Gets the internal `IDBTransaction` object
-     *
-     * It's recommended you don't use this function and use the built-in functions of the wrapper
-     * @returns Internal transaction object
-     */
-    getInternal(): IDBTransaction;
-    getStore(store: Stores): ObjectStore;
-    get mode(): Mode;
-    is(status: TransactionStatus): boolean;
-    contains(stores: Arrayable<string>): boolean;
-    assertIsArray(value: any, message?: string): asserts value is any[];
-    private getObjectstore;
-    private registerHandler;
-    wrap<Output>(fn: (tx: this) => Promise<Output>): Promise<Output>;
-}

package/dist/tsconfig.tsbuildinfo

@@ -1 +0,0 @@
-{"root":["../src/builder.ts","../src/error.ts","../src/index.ts","../src/object-store.ts","../src/transaction.ts","../src/types.ts","../src/utils.ts","../src/client/compiled-query.ts","../src/client/delete.ts","../src/client/helpers.ts","../src/client/index.ts","../src/client/types/find.ts","../src/client/types/index.ts","../src/client/types/mutation.ts","../src/field/field-types.ts","../src/field/index.ts","../src/field/primary-key.ts","../src/field/property.ts","../src/field/relation.ts","../src/model/index.ts","../src/model/model-types.ts","../src/model/model.ts","../tests/helpers.ts","../tests/test.spec.ts"],"version":"5.9.3"}

package/dist/types/common.d.ts

@@ -1,48 +0,0 @@
-/**
- * Extracts the string keys of an object
- */
-export type Keyof<T extends Record<any, any>> = Extract<keyof T, string>;
-export type Arrayable<T> = T | T[];
-export type IsNever<T> = [T] extends [never] ? true : false;
-export type Promisable<T> = T | Promise<T>;
-export type NoUndefined<T> = Exclude<T, undefined>;
-export declare enum Type {
-    String = 0,
-    Number = 1,
-    BigInt = 2,
-    Boolean = 3,
-    Symbol = 4,
-    Array = 5,
-    Date = 6,
-    Object = 7,
-    Unknown = 8
-}
-export type MakeOptional<B extends boolean, T> = B extends true ? T | undefined : T;
-export type MakeArray<B extends boolean, T> = B extends true ? T[] : T;
-export type MakeArrayable<B extends boolean, T> = B extends true ? Arrayable<T> : T;
-export type ValidKey = string | number | Date;
-export type ValidKeyType = "string" | "number" | "date";
-export type If<Type extends boolean, IfBranch, ElseBranch> = IsNever<Type> extends true ? ElseBranch : Type extends true ? IfBranch : ElseBranch;
-export type RemoveNeverValues<T extends object> = {
-    [K in keyof T as T[K] extends never ? never : K]: T[K];
-};
-export type Dict<T = unknown> = Record<string, T>;
-export type ConnectionObject<M extends boolean = false, T = object, K = ValidKey> = {
-    $create: T;
-    $connect: K;
-} & If<M, {
-    $createMany: T[];
-    $connectMany: K[];
-}, Dict>;
-type UndefinedKeys<T extends Dict> = {
-    [K in Keyof<T>]: undefined extends T[K] ? K : never;
-}[Keyof<T>];
-type Optional<T extends Dict> = Partial<Pick<T, UndefinedKeys<T>>>;
-type Required<T extends Dict> = Omit<T, UndefinedKeys<T>>;
-export type PartialOnUndefined<T extends Dict> = Required<T> & Optional<T>;
-/**
- * Types that can be resolved to specific boolean values
- */
-export type BooleanLike = boolean | undefined | null | 0;
-export type Literable = string | number | bigint | boolean | null | undefined;
-export {};

package/dist/types.d.ts

@@ -1,48 +0,0 @@
-/**
- * Extracts the string keys of an object
- */
-export type Keyof<T extends Record<any, any>> = Extract<keyof T, string>;
-export type Arrayable<T> = T | T[];
-export type IsNever<T> = [T] extends [never] ? true : false;
-export type Promisable<T> = T | Promise<T>;
-export type NoUndefined<T> = Exclude<T, undefined>;
-export declare enum Type {
-    String = 0,
-    Number = 1,
-    BigInt = 2,
-    Boolean = 3,
-    Symbol = 4,
-    Array = 5,
-    Date = 6,
-    Object = 7,
-    Unknown = 8
-}
-export type MakeOptional<B extends boolean, T> = B extends true ? T | undefined : T;
-export type MakeArray<B extends boolean, T> = B extends true ? T[] : T;
-export type MakeArrayable<B extends boolean, T> = B extends true ? Arrayable<T> : T;
-export type ValidKey = string | number | Date;
-export type ValidKeyType = "string" | "number" | "date";
-export type If<Type extends boolean, IfBranch, ElseBranch> = IsNever<Type> extends true ? ElseBranch : Type extends true ? IfBranch : ElseBranch;
-export type RemoveNeverValues<T extends object> = {
-    [K in keyof T as T[K] extends never ? never : K]: T[K];
-};
-export type Dict<T = unknown> = Record<string, T>;
-export type ConnectionObject<M extends boolean = false, T = object, K = ValidKey> = {
-    $create: T;
-    $connect: K;
-} & If<M, {
-    $createMany: T[];
-    $connectMany: K[];
-}, Dict>;
-type UndefinedKeys<T extends Dict> = {
-    [K in Keyof<T>]: undefined extends T[K] ? K : never;
-}[Keyof<T>];
-type Optional<T extends Dict> = Partial<Pick<T, UndefinedKeys<T>>>;
-type Required<T extends Dict> = Omit<T, UndefinedKeys<T>>;
-export type PartialOnUndefined<T extends Dict> = Required<T> & Optional<T>;
-/**
- * Types that can be resolved to specific boolean values
- */
-export type BooleanLike = boolean | undefined | null | 0;
-export type Literable = string | number | bigint | boolean | null | undefined;
-export {};

package/dist/util-types.d.ts

@@ -1,37 +0,0 @@
-/**
- * Extracts the string keys of an object
- */
-export type Keyof<T extends Record<any, any>> = Extract<keyof T, string>;
-export type Arrayable<T> = T | T[];
-export type IsNever<T> = [T] extends [never] ? true : false;
-export type Promisable<T> = T | Promise<T>;
-export type NoUndefined<T> = Exclude<T, undefined>;
-export type MakeOptional<B extends boolean, T> = B extends true ? T | undefined : T;
-export type MakeArray<B extends boolean, T> = B extends true ? T[] : T;
-export type MakeArrayable<B extends boolean, T> = B extends true ? Arrayable<T> : T;
-export type ValidKey = string | number | Date;
-export type ValidKeyType = "string" | "number" | "date";
-export type If<Type extends boolean, IfBranch, ElseBranch> = IsNever<Type> extends true ? ElseBranch : Type extends true ? IfBranch : ElseBranch;
-export type RemoveNeverValues<T extends object> = {
-    [K in keyof T as T[K] extends never ? never : K]: T[K];
-};
-export type Dict<T = unknown> = Record<string, T>;
-export type ConnectionObject<M extends boolean = false, T = object, K = ValidKey> = {
-    $create: T;
-    $connect: K;
-} & If<M, {
-    $createMany: T[];
-    $connectMany: K[];
-}, Dict>;
-type UndefinedKeys<T extends Dict> = {
-    [K in Keyof<T>]: undefined extends T[K] ? K : never;
-}[Keyof<T>];
-type Optional<T extends Dict> = Partial<Pick<T, UndefinedKeys<T>>>;
-type Required<T extends Dict> = Omit<T, UndefinedKeys<T>>;
-export type PartialOnUndefined<T extends Dict> = Required<T> & Optional<T>;
-/**
- * Types that can be resolved to specific boolean values
- */
-export type BooleanLike = boolean | undefined | null | 0;
-export type Literable = string | number | bigint | boolean | null | undefined;
-export {};

package/dist/utils.d.ts

@@ -1,29 +0,0 @@
-import { Arrayable, Keyof, ValidKeyType } from "./util-types";
-import type { Transaction } from "./transaction.js";
-export declare function handleRequest<T>(req: IDBRequest<T>, tx?: Transaction<any, any>): Promise<T>;
-export declare function getKeys<T extends object>(obj: T): Keyof<T>[];
-export declare function addToSet<T>(set: Set<T>, items: T[]): Set<T>;
-export declare function toArray<T>(value: Arrayable<T>): T[];
-export declare function stringTypeToEnum(type: ValidKeyType): Type;
-export declare function uuid(): `${string}-${string}-${string}-${string}-${string}`;
-/**
- * Identity Function, it returns the first argument it is given, all others are ignored
- * @param value Value
- * @returns Same Value
- */
-export declare function identity<T>(value: T): T;
-/**
- * Performs a union over `set1` and `set2`, modifying `set1` to be union of the two sets
- */
-export declare function unionSets<T>(set: Set<T>, other: Set<T>): Set<T>;
-export declare enum Type {
-    String = 0,
-    Number = 1,
-    BigInt = 2,
-    Boolean = 3,
-    Symbol = 4,
-    Array = 5,
-    Date = 6,
-    Object = 7,
-    Unknown = 8
-}