@idb-orm/core 1.0.7 → 1.0.9

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/dist/builder.d.ts

@@ -1,16 +1,14 @@
-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>;
-};
+import { CollectionObject, CollectionSchema, FindPrimaryKey, Model } from './model';
+import { DbClient } from './client';
+import { ValidValue } from './field';
+import { Dict } from './util-types';
 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>>;
+    defineModel<N extends Names, T extends Dict<ValidValue<Names>>>(model: Model<N, T, FindPrimaryKey<T>>): Model<N, T, FindPrimaryKey<T>>;
+    defineModel<N extends Names, T extends Dict<ValidValue<Names>>>(name: N, values: T): Model<N, T, FindPrimaryKey<T>>;
     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>> {

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

@@ -1,6 +1,6 @@
-import type { CollectionObject } from "../builder.ts";
-import type { DbClient } from "./index.ts";
-import type { FindInput, FindOutput } from "./types/find.ts";
+import { CollectionObject } from '../model';
+import { DbClient } from './index.ts';
+import { 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;

package/dist/client/delete.d.ts

@@ -1,8 +1,7 @@
-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";
+import { CollectionObject, ExtractFields } from '../model';
+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

package/dist/client/helpers.d.ts

@@ -1,10 +1,18 @@
-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;
+import { Dict, Promisable } from '../util-types.js';
+import { DbClient } from './index.ts';
+import { QueryInput } from './types/find.ts';
+import { Transaction } from '../transaction.js';
+import { CollectionObject } from '../model';
+type WhereClauseElement = [key: string, isFun: true, fn: (value: unknown) => boolean] | [key: string, isFun: false, value: unknown];
+export declare function generateWhereClause(where?: Dict): WhereClauseElement[];
+/**
+ * Parses a WhereClause array and returns if the item passes the checks or not
+ * @param whereArray Result of `generateWhereClause()`
+ * @param obj Object to check
+ * @returns If the object satisfies the where clause or not
+ */
+export declare function parseWhere(whereArray: WhereClauseElement[], 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;
+export declare function getAccessedStores<ModelNames extends string, Models extends CollectionObject<ModelNames>>(name: ModelNames, query: Dict, isMutation: boolean, 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 {};

package/dist/client/index.d.ts

@@ -1,7 +1,9 @@
-import type { CollectionObject, CompiledDb } from "../builder";
-import type { Arrayable } from "../util-types";
-import { Transaction, type TransactionOptions } from "../transaction";
-import { type InterfaceMap } from "./types";
+import { CompiledDb } from '../builder';
+import { Arrayable } from '../util-types';
+import { CollectionObject } from '../model';
+import { Transaction, TransactionOptions } from '../transaction';
+import { InterfaceMap } from './types';
+import { CsvDump, JsonDump } from '../dump/class.js';
 export declare class DbClient<Name extends string, ModelNames extends string, Models extends CollectionObject<ModelNames>> {
     private readonly db;
     private readonly models;
@@ -9,9 +11,12 @@ export declare class DbClient<Name extends string, ModelNames extends string, Mo
     readonly version: number;
     readonly stores: InterfaceMap<ModelNames, Models>;
     constructor(db: IDBDatabase, models: CompiledDb<Name, ModelNames, Models>);
+    getDb(): IDBDatabase;
     getStore<Name extends ModelNames>(name: Name): (typeof this.stores)[Name];
+    getStoreNames(): ModelNames[];
     createTransaction<Mode extends IDBTransactionMode, Names extends ModelNames>(mode: Mode, stores: Arrayable<Names>, options?: TransactionOptions): Transaction<Mode, Names>;
     deleteDb(): Promise<void>;
+    dump<Format extends "json" | "csv", Return = Format extends "json" ? JsonDump : CsvDump>(format: Format, stores?: ModelNames[]): Promise<Return>;
     deleteAllStores(): void;
     deleteStore(storeNames: Arrayable<ModelNames>): void;
     getModel<N extends ModelNames>(name: N): Models[N];
@@ -29,5 +34,26 @@ export declare class DbClient<Name extends string, ModelNames extends string, Mo
      */
     private find;
     private update;
-    private updateSingleton;
+    /**
+     * Connects a document to another
+     *
+     * **This must be called within a wrapped environment**
+     * @param relation Relation object
+     * @param thisId Id of the source document
+     * @param documentId If of the target document
+     * @param tx Transaction this function is wrapped in
+     * @returns Id of the target document
+     */
+    private connectDocument;
+    /**
+     * Disconnects a document from another
+     *
+     * **This must be called within a wrapped environment**
+     * @param relation Relation object
+     * @param thisId Id of the source document
+     * @param documentId If of the target document
+     * @param tx Transaction this function is wrapped in
+     * @returns Id of the target document
+     */
+    private disconnectDocument;
 }

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

@@ -1,15 +1,14 @@
-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";
+import { Dict, If, Keyof, MakeRequired, NoUndefined, RemoveNeverValues, Simplify } from '../../util-types.js';
+import { ExtractFields, ModelStructure, RelationlessModelStructure, RelationValue } from '../../model/model-types';
+import { Model, CollectionObject } from '../../model';
+import { BaseRelation, AbstractProperty, PrimaryKey, RelationOutputStructure, ValidValue, Relation } from '../../field';
 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 ProhibitObjects<T> = T extends Date ? Date : 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;
+    [K in keyof Fields]: Fields[K] extends AbstractProperty<infer Output, any> ? ProhibitObjects<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;
@@ -20,8 +19,11 @@ export interface QueryInput<All extends string, Fields extends Dict<ValidValue>,
     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;
+type SelectOutput<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, any, any> ? If<Select[K] extends true ? true : false, RelationOutputStructure<Fields[K], RelationlessModelStructure<C[To]>>, Select[K] extends FindInput<All, C[To], C> ? RelationOutputStructure<Fields[K], FindOutput<All, C[To], C, Select[K]>> : never> : never : never : Fields[K] extends PrimaryKey<any, infer Type> ? Type : Fields[K] extends AbstractProperty<infer Type, any> ? Type : never;
+};
+type IncludeOutput<All extends string, Include extends Dict<Dict | true>, Fields extends Dict<ValidValue>, C extends CollectionObject<All>> = Simplify<{
+    [K in Keyof<Fields>]: Fields[K] extends BaseRelation<infer To, any> ? To extends Keyof<C> ? C[To] extends Model<any, any, any> ? K extends Keyof<Include> ? Include[K] extends true ? RelationOutputStructure<Fields[K], RelationlessModelStructure<C[To]>> : Include[K] extends FindInput<All, C[To], C> ? MakeRequired<Fields[K] extends Relation<any, any> ? true : false, NoUndefined<RelationOutputStructure<Fields[K], NoUndefined<FindOutput<All, C[To], C, Include[K]>>>>> : unknown : RelationOutputStructure<Fields[K], RelationValue<To, C>> : never : never : Fields[K] extends PrimaryKey<any, infer Type> ? Type : Fields[K] extends AbstractProperty<infer Type, any> ? Type : never;
+}>;
+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> ? Simplify<F["select"] extends Dict<true | Dict> ? SelectOutput<All, F["select"], Fields, C> : F["include"] extends Dict<true | Dict> ? IncludeOutput<All, F["include"], Fields, C> : ModelStructure<ExtractFields<Struct>, C>> | undefined : never;
 export {};

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

@@ -1,31 +1,28 @@
-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>> {
+import { Dict, Simplify } from '../../util-types.js';
+import { ExtractFields, Model, ModelStructure, PrimaryKeyType, CollectionObject } from '../../model';
+import { AddMutation, MutationAction, UpdateMutation } from './mutation.ts';
+import { FindInput, FindOutput, WhereObject } from './find.ts';
+import { CompiledQuery } from '../compiled-query.ts';
+import { DbClient } from '../index.ts';
+import { Transaction } from '../../transaction.js';
+import { BaseRelation, ValidKey } from '../../field';
+import { CsvDump, JsonDump } from '../../dump/class.js';
+export type GetStructure<N extends string, C extends Dict> = C[N] extends Model<N, infer F, any> ? Simplify<ModelStructure<F, C>> : never;
+export type ExportFormat = "json";
+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 extends UpdateMutation<Name, Names, C[Name], C> = 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>[]>;
+    find<T extends FindInput<Names, C[Name], C>>(query: T, transaction?: Transaction<IDBTransactionMode, Names>): Promise<NonNullable<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[]>;
+    update(key: KeyType, data: Update["data"]): Promise<GetStructure<Name, C>>;
+    updateFirst(item: Update, transaction?: Transaction<"readwrite", Names>): Promise<GetStructure<Name, C> | undefined>;
+    updateMany(item: Update, transaction?: Transaction<"readwrite", Names>): Promise<GetStructure<Name, C>[]>;
     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>;
+    get(key: KeyType): Promise<GetStructure<Name, C> | undefined>;
+    dump<Format extends ExportFormat>(format: Format, where?: WhereObject<C[Name] extends Model<any, infer Fields, any> ? Fields : never>): Promise<Format extends "json" ? JsonDump : CsvDump>;
 }
 export type InterfaceMap<Names extends string, C extends CollectionObject<Names>> = {
     [K in Names]: StoreInterface<K, Names, C>;
@@ -33,10 +30,6 @@ export type InterfaceMap<Names extends string, C extends CollectionObject<Names>
 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: {
@@ -46,17 +39,25 @@ export interface MutationState<Names extends string> extends Partial<{
     singleton: {
         id: ValidKey;
     };
+    /**
+     * Flag indicating whether or not this is the final step of the query/mutation
+     * @default true
+     */
     finalStep: boolean;
 }> {
 }
-export type KeyObject<Index = string> = {
-    isFun: boolean;
+export type ActionItem = [action: MutationAction, value: unknown];
+export type KeyObject<Index = string> = ({
     key: Index;
 } & ({
     isRelation: true;
+    actions: ActionItem[];
     relation: BaseRelation<any, any>;
+    updateFn?: undefined;
 } | {
     isRelation: false;
+    actions?: undefined;
     relation?: undefined;
-});
+    updateFn: <T>(value: T) => T;
+}));
 export type { AddMutation, UpdateMutation };

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

@@ -1,46 +1,49 @@
-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, {
+import { MakeArrayable, MakeOptional, RemoveNeverValues, PartialOnUndefined, Extends, If, Or, Keyof } from '../../util-types.js';
+import { BaseRelation, AbstractProperty, OptionalRelation, PrimaryKey, ArrayRelation } from '../../field';
+import { WhereObject } from './find.js';
+import { Model, FindRelationKey, RelationValue, CollectionObject } from '../../model';
+export type MutationAction = "$connect" | "$connectMany" | "$create" | "$createMany" | "$update" | "$updateMany" | "$delete" | "$deleteMany" | "$deleteAll" | "$disconnect" | "$disconnectMany" | "$disconnectAll";
+type WhereSelection<Struct extends object> = Struct extends Model<any, infer Fields, any> ? WhereObject<Fields> : never;
+type _UpdateRelationMutation<This extends All, All extends string, C extends CollectionObject<All>, To extends All, Name extends string, Relation extends BaseRelation<To, Name>, ThisKey extends string, OmitKeys extends string, IsOptional extends boolean = Extends<Relation, OptionalRelation<any, any>>, IsArray extends boolean = Extends<Relation, ArrayRelation<any, any>>, IsNullable extends boolean = Or<IsOptional, IsArray>> = MakeOptional<IsNullable, MakeArrayable<IsArray, {
+    $connect: RelationValue<To, C>;
+} | {
+    $create: Omit<AddMutation<To, All, C[To], C>, OmitKeys | FindRelationKey<This, Name, C[To]>>;
+} | {
+    $update: If<IsArray, UpdateMutation<To, All, C[To], C, OmitKeys | ThisKey>, Omit<UpdateMutation<To, All, C[To], C>["data"], OmitKeys>>;
+} | If<IsNullable, {
+    $delete: If<IsArray, RelationValue<To, C>, true>;
+} | {
+    $disconnect: If<IsArray, RelationValue<To, C>, true>;
+}, never>> | If<IsArray, {
+    $connectMany: RelationValue<To, C>[];
+} | {
+    $createMany: Omit<AddMutation<To, All, C[To], C>, OmitKeys | FindRelationKey<This, Name, C[To]>>[];
+} | {
+    $updateMany: UpdateMutation<To, All, C[To], C, OmitKeys | ThisKey>[];
+} | {
+    $deleteMany: RelationValue<To, C>[];
+} | {
+    $deleteAll: true;
+} | {
+    $disconnectMany: RelationValue<To, C>[];
+} | {
+    $disconnectAll: true;
+}, never>>;
+export type UpdateMutation<This extends All, All extends string, Struct extends object, C extends CollectionObject<All>, OmitKeys extends string = never> = {
+    where?: WhereSelection<Struct>;
+    data: PartialOnUndefined<RemoveNeverValues<Struct extends Model<any, infer Fields, any> ? {
+        [K in Exclude<Keyof<Fields>, OmitKeys>]: Fields[K] extends AbstractProperty<infer Type, any> ? Type | undefined | ((value: Type) => Type) : Fields[K] extends PrimaryKey<any, any> ? never : Fields[K] extends BaseRelation<infer To, infer Name> ? To extends All ? _UpdateRelationMutation<This, All, C, To, Name, Fields[K], K, OmitKeys> | undefined : never : never;
+    } : never>>;
+};
+export type AddMutation<This extends All, All extends string, Struct extends object, C extends CollectionObject<All>> = PartialOnUndefined<RemoveNeverValues<Struct extends Model<any, infer Fields, any> ? {
+    [K in keyof Fields]: Fields[K] extends AbstractProperty<infer Type, infer HasDefault> ? HasDefault extends true ? Type | undefined : Type : Fields[K] extends PrimaryKey<infer IsAuto, infer Type> ? 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 : 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> ? {
+        $create: Omit<AddMutation<To, All, C[To], C>, FindRelationKey<This, Name, C[To]>>;
+    }> | (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;
+        $createMany: Omit<AddMutation<To, All, C[To], C>, FindRelationKey<This, Name, C[To]>>[];
     } : 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/core.d.ts

@@ -0,0 +1,11 @@
+export { AbstractProperty } from './field/property';
+export type { ParseFn, PropertyOptions, PropertyInputOptions, } from './field/property';
+export type { PropertyUnion } from './field/field-types';
+export * from './util-types';
+export { Model } from './model';
+export type { FindPrimaryKey } from './model';
+export { VALIDATORS } from './field/validators.js';
+export * from './field';
+export * from './client';
+export { Type } from './field/type-wrapper';
+export type { TypeTag } from './field/type-wrapper';

package/dist/dump/class.d.ts

@@ -0,0 +1,22 @@
+import { Arrayable, Dict } from '../util-types';
+declare abstract class Dump<T> {
+    protected readonly name: string;
+    protected readonly content: T;
+    protected readonly extension: string;
+    constructor(name: string, content: T, extension: string);
+    abstract getValue(): T;
+    abstract toFile(filename?: string, options?: FilePropertyBag): File;
+    download(filename?: string, options?: FilePropertyBag): void;
+}
+type JsonValue = Arrayable<Dict>;
+export declare class JsonDump extends Dump<JsonValue> {
+    constructor(name: string, content: JsonValue);
+    getValue(): JsonValue;
+    toFile(filename?: string, options?: FilePropertyBag): File;
+}
+export declare class CsvDump extends Dump<string> {
+    constructor(name: string, content: string);
+    getValue(): string;
+    toFile(filename?: string, options?: FilePropertyBag): File;
+}
+export {};

package/dist/dump/json.d.ts

@@ -0,0 +1,9 @@
+import { WhereObject } from '../client/types/find.js';
+import { Dict } from '../util-types';
+import { DbClient } from '../client';
+import { ValidValue } from '../field';
+import { CollectionObject } from '../model';
+import { Transaction } from '../transaction.js';
+import { JsonDump } from './class.js';
+export declare function dumpStoreToJson<Current extends Names, Names extends string, Models extends CollectionObject<Names>>(db: DbClient<string, Names, CollectionObject<Names>>, store: Current, where?: WhereObject<Models[Current] extends Dict<ValidValue> ? Models[Current] : never>, tx?: Transaction<"readonly", Names>): Promise<JsonDump>;
+export declare function dumpDatabaseToJSON<Names extends string>(db: DbClient<string, Names, any>, stores?: Names[]): Promise<JsonDump>;

package/dist/error.d.ts

@@ -1,4 +1,4 @@
-export type ErrorType = "ID_EXISTS" | "INVALID_ITEM" | "ADD_FAILED" | "UPDATE_FAILED" | "DELETE_FAILED" | "OVERWRITE_RELATION" | "NOT_FOUND" | "GET_FAILED"
+export type ErrorType = "ID_EXISTS" | "INVALID_ITEM" | "ADD_FAILED" | "UPDATE_FAILED" | "DELETE_FAILED" | "OVERWRITE_RELATION" | "NOT_FOUND" | "GET_FAILED" | "EXPORT"
 /**
  * The given transaction is invalid for the store it is trying to access
  */
@@ -9,14 +9,13 @@ export type ErrorType = "ID_EXISTS" | "INVALID_ITEM" | "ADD_FAILED" | "UPDATE_FA
  | "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;
+        message: string;
         stack?: string;
         cause?: unknown;
     };
@@ -30,8 +29,8 @@ export declare const InvalidConfigError: {
 export declare const InvalidTransactionError: {
     new (message?: string): {
         readonly code: ErrorType;
-        readonly message: string;
         name: string;
+        message: string;
         stack?: string;
         cause?: unknown;
     };
@@ -45,8 +44,8 @@ export declare const InvalidTransactionError: {
 export declare const InvalidItemError: {
     new (message?: string): {
         readonly code: ErrorType;
-        readonly message: string;
         name: string;
+        message: string;
         stack?: string;
         cause?: unknown;
     };
@@ -60,8 +59,8 @@ export declare const InvalidItemError: {
 export declare const AssertionError: {
     new (message?: string): {
         readonly code: ErrorType;
-        readonly message: string;
         name: string;
+        message: string;
         stack?: string;
         cause?: unknown;
     };
@@ -75,8 +74,8 @@ export declare const AssertionError: {
 export declare const UnknownError: {
     new (message?: string): {
         readonly code: ErrorType;
-        readonly message: string;
         name: string;
+        message: string;
         stack?: string;
         cause?: unknown;
     };
@@ -90,8 +89,8 @@ export declare const UnknownError: {
 export declare const DeleteError: {
     new (message?: string): {
         readonly code: ErrorType;
-        readonly message: string;
         name: string;
+        message: string;
         stack?: string;
         cause?: unknown;
     };
@@ -105,8 +104,8 @@ export declare const DeleteError: {
 export declare const ObjectStoreNotFoundError: {
     new (message?: string): {
         readonly code: ErrorType;
-        readonly message: string;
         name: string;
+        message: string;
         stack?: string;
         cause?: unknown;
     };
@@ -120,8 +119,8 @@ export declare const ObjectStoreNotFoundError: {
 export declare const DocumentNotFoundError: {
     new (message?: string): {
         readonly code: ErrorType;
-        readonly message: string;
         name: string;
+        message: string;
         stack?: string;
         cause?: unknown;
     };
@@ -135,8 +134,8 @@ export declare const DocumentNotFoundError: {
 export declare const UpdateError: {
     new (message?: string): {
         readonly code: ErrorType;
-        readonly message: string;
         name: string;
+        message: string;
         stack?: string;
         cause?: unknown;
     };
@@ -150,8 +149,8 @@ export declare const UpdateError: {
 export declare const AddError: {
     new (message?: string): {
         readonly code: ErrorType;
-        readonly message: string;
         name: string;
+        message: string;
         stack?: string;
         cause?: unknown;
     };
@@ -165,8 +164,8 @@ export declare const AddError: {
 export declare const OpenCursorError: {
     new (message?: string): {
         readonly code: ErrorType;
-        readonly message: string;
         name: string;
+        message: string;
         stack?: string;
         cause?: unknown;
     };
@@ -180,8 +179,8 @@ export declare const OpenCursorError: {
 export declare const RetrievalError: {
     new (message?: string): {
         readonly code: ErrorType;
-        readonly message: string;
         name: string;
+        message: string;
         stack?: string;
         cause?: unknown;
     };
@@ -192,3 +191,33 @@ export declare const RetrievalError: {
     prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
     stackTraceLimit: number;
 };
+export declare const OverwriteRelationError: {
+    new (message?: string): {
+        readonly code: ErrorType;
+        name: string;
+        message: string;
+        stack?: string;
+        cause?: unknown;
+    };
+    readonly code: "OVERWRITE_RELATION";
+    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 ExportError: {
+    new (message?: string): {
+        readonly code: ErrorType;
+        name: string;
+        message: string;
+        stack?: string;
+        cause?: unknown;
+    };
+    readonly code: "EXPORT";
+    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;
+};