@idb-orm/core 1.0.11 → 1.0.13

package/README.md

@@ -1,39 +1,198 @@
-# IDB-ORM
+# IDB-ORM Core
 
-> THIS PROJECT IS STILL A (ROUGH) WORK IN PROGRESS. I HOPE TO HAVE A GOOD WORKING VERSION SOON.
->
-> PLEASE CHECK BACK IN A FEW WEEKS/MONTHS
+> # IMPORTANT: THIS PROJECT IS STILL IN THE VERY EARLY STAGES. USE AT YOUR OWN RISK
 
-## Roadmap
+A simple object relational mapper for the [IndexedDB API](https://developer.mozilla.org/en-US/docs/Web/API/IndexedDB_API). IndexedDB (IDB) is a NoSQL database built into modern web browsers. This package wraps around that API and turns it into a pseudo-relational database. This allows features like:
+
+-   Defining relations between documents
+-   Querying on these relations (and the relations of the related document)
+-   Performing actions when the corresponding item of the relation changes
+-   Updating items based on nested relation querying
+
+## Installation
+
+The minimum you need to get started is the `core` package. Although there are other supplemental packages that add extra features.
+
+```
+npm install @idb-orm/core
+```
+
+## Getting Started
+
+First thing you'll need to do is create a `builder` object. This will create the IDB object stores. The constructor takes in the name of the database and a list of object store names.
+
+```ts
+import { Builder, Property as P } from "@idb-orm/core";
+
+const builder = new Builder("test_db", ["users", "posts", "comments"]);
+```
+
+## Understanding the Different Components
+
+Before you can define a model, you need to understand the different components of one. A model definition is made up of three different components.
+
+-   One primary key definition
+-   Zero or more Property definitions
+-   Zero or more Relation definitions
+
+Each component is slightly different in how it is instantiated and used when defining a model.
+
+### Primary Key Definition
+
+A primary key is a **unique** identifier used to store your document in the database. A primary key can be a `string`, `number`, or `Date` type (I may include support for more types down the line):
+
+```ts
+// A number primary key (default)
+P.primaryKey();
+
+// A string primary key
+P.primaryKey("string");
+
+// A date primary key
+P.primaryKey("date");
+```
+
+In their base states, when creating a document the primary key must be supplied. However you can attach generators which will automatically generate the primary key when a document is created.
+
+```ts
+// Creates a auto-incrementing number primary key
+P.primaryKey().autoIncrement();
+
+// Creates a string primary key that is a UUIDv4
+P.primaryKey().uuid();
+
+// Or, define your own generator
+P.primaryKey("string").generator(
+    () => `${new Date()}-${Math.round(Math.random() * 10000)}`
+);
+```
+
+> **Note:** If the given primary key of a document is not unique, the creation of that document will fail. It's recommended to use either the `.autoIncrement()` utility for number primary keys or `.uuid()` for string primary keys.
+
+### Property Definition
+
+This is the basic building block for a model. It lets you define static fields of the document. They are used for validating model input and providing the proper typescript interface for later queries/mutations.
 
--   [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
--   [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:
+-   `P.string()`: Defines a string field
+-   `P.number()`: Defines a number field
+-   `P.boolean()`: Defines a boolean field
+-   `P.date()`: Defines a date field
+-   `P.literal([value])`: Defines a literal type. Meaning that the field will always consist of `[value]`
+-   `P.array([Property])`: Defines an array field where the array's elements are defined by `[Property]`
+-   `P.set([Property])`: Defines a set field where the set's elements are defined by `[Property]`
+-   `P.union([Property1, Property2, ...])`: Defines a union type where any value that matches the given `[PropertyX]` will satisfy the validation.
+-   `P.custom<T>((test: unknown) => boolean)`: Defines a field for a custom type that is validated by a function passed in as the first argument.
+
+    For this type of field, if you plan on dumping your database to other formats, it's also recommended you populate the second `options` argument with these functions:
+
+    -   `serialize: (value: T) -> unknown`: Serializes the type to JSON.
+    -   `deserialize: (value: unknown) -> T`: De-serializes the type to JSON.
+
+    If these functions are omitted it will use `JSON.stringify()` and `JSON.parse()` respectfully.
+
+Additionally, there are methods of the `Property` class that allows you to attach identifiers to these properties:
+
+-   `.array()`: Makes the field an array of the preceeding property.
+-   `.optional()`: Makes a field optional. It can now be omitted when a document is being created. The value in the resulting document will be undefined. This is functionally equivalent to doing `P.union([..., P.literal(undefined)])`, but with less overhead.
+-   `.default([value])`: Same behavior as optional, but instead of being undefined the value will be filled in with the given default value.
+
+### Relation Definition
+
+Relation definitions are how you define relations between models/stores. Relations can be between different stores or the same store. There are three types of relation definitions:
+
+-   `P.relation([modelName], options?)`: The default, describing a relation from the current model to a `[modelName]` document.
+-   `P.relation([modelName], options?).optional()`: Describes a relation from the current model to a `[modelName]` document, where it's possible that the value on this not defined (null).
+-   `P.relation([modelName], options?).array()`: Describes a relation from the current model to several different documents in model `[modelName]`.
+
+```ts
+interface RelationOptions {
+    name?: string;
+    onDelete?: "SetNull" | "None" | "Restrict" | "Cascade";
+}
+```
+
+All relations must be bidirectional, so for every relation on some model X to model Y, there must be a corresponding relation object on model Y that points to model X. If you omit it, the builder will throw an error. You can pass in additional options to the relation, such as a name. Giving a relation a name is highly recommended to ensure the builder correctly relates model fields. Under the hood, this relation field is storing the primary keys of the documents you are relating to.
+
+Additionally, you can attach actions to be performed when a document is deleted:
+
+-   `SetNull`: Only usable when the relation this one is pointing to is optional or an array. In which case it sets the corresponding field to null or removes the element respectively.
+-   `None`: Performs no action when a delete occurs.
+-   `Restrict`: This item essentially cannot be deleted. Attempted to delete it will throw an error.
+-   `Cascade`: Deleting this document will try to delete the pointed to document(s).
+
+## Putting it all together
+
+```ts
+import { Builder, Property as P } from "@idb-orm/core";
+
+const builder = new Builder("test_db", ["users", "posts", "comments"]);
+
+const userStore = builder.defineModel("users", {
+    id: P.primaryKey().uuid(),
+    name: P.string(),
+    email: P.string(),
+    password: P.string(),
+    accountCreated: P.date().default(() => new Date()),
+    posts: P.relation("posts", { name: "postsToUsers" }).array({
+        // If this user account gets deleted, delete all their posts
+        onDelete: "Cascade",
+    }),
+    comments: P.relation("comments", { name: "commentsToUsers" }).array(),
+});
+
+const postStore = builder.defineModel("posts", {
+    id: P.primaryKey().autoIncrement(),
+    created: P.date().default(() => new Date()),
+    title: P.string(),
+    body: P.string().array(),
+    likes: P.number().default(0),
+    dislikes: P.number().default(0),
+    author: P.relation("users", { name: "postsToUsers" }),
+    comments: P.relation("comments", { name: "postToComments" }).array({
+        onDelete: "Cascade",
+    }),
+});
+
+const commentStore = builder.defineModel("comments", {
+    id: P.primaryKey().autoIncrement(),
+    created: P.date().default(() => new Date()),
+    modified: P.date().default(() => new Date()),
+    content: P.string(),
+    likes: P.number().default(0),
+    dislikes: P.number().default(0),
+    author: P.relation("users", { name: "commentsToUsers" }),
+    post: P.relation("posts", { name: "postToComments" }),
+});
+```
+
+Then once you have all of your model definitions, call the `compile` function. This steps performs sanity checks on your model definitions and will throw errors if anything goes wrong. Once the model is compiled, you can create the client.
+
+```ts
+const compiledDb = builder.compile({
+    users: userStore,
+    posts: postStore,
+    comments: commentStore,
+});
+
+const client = await compiledDb.createClient();
+```
+
+_To be continued..._
+
+## Roadmap
+-   [ ] Restore database to different formats
     -   [ ] JSON
     -   [ ] CSV
--   [ ] 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
     -   [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
+

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

@@ -1,7 +1,7 @@
 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>> {
+import { FindInput, FindOutput } from './types/find';
+export declare class CompiledQuery<Stores extends string, Models extends CollectionObject<string>, Db extends DbClient<string, Stores, Models>, Input extends FindInput<Stores, Stores, Models> = FindInput<Stores, Stores, Models>, Output = FindOutput<Stores, Stores, Models, Input>> {
     private readonly client;
     private readonly name;
     private readonly accessedStores;

package/dist/client/dump.d.ts

@@ -0,0 +1,27 @@
+import { Dict } from '../util-types';
+import { ExportFormat } from './types';
+import { DbClient } from '.';
+import { WhereObject } from './types/find.js';
+import { ValidValue } from '../field';
+import { CollectionObject, Model } from '../model';
+import { Transaction } from '../transaction.js';
+/**
+ * Removes reserved characters from a JSON pointer string
+ */
+export declare function clean(text: unknown): string;
+export declare function getStoreData<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<Dict>;
+export declare function getDatabaseData<Names extends string>(db: DbClient<string, Names, any>, stores?: Names[]): Promise<Dict<Dict>>;
+export interface DumpOptions {
+    pretty?: boolean;
+}
+export declare class Dump<F extends ExportFormat> {
+    protected readonly name: string;
+    protected readonly content: string;
+    protected readonly extension: F;
+    constructor(name: string, content: string, extension: F);
+    toFile(filename?: string, options?: FilePropertyBag): File;
+    download(filename?: string, options?: FilePropertyBag): void;
+    static toJson(name: string, content: Dict, options?: DumpOptions): Dump<"json">;
+    static toCsvStore(model: Model<string, any, string>, content: Dict): Dump<"csv">;
+    static toCsvDb(db: DbClient<string, string, CollectionObject<string>>, stores: string[], content: Dict<Dict>): Dump<"csv">;
+}

package/dist/client/helpers.d.ts

@@ -1,6 +1,6 @@
 import { Dict, Promisable } from '../util-types.js';
 import { DbClient } from './index.ts';
-import { QueryInput } from './types/find.ts';
+import { QueryInput } from './types/find';
 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];
@@ -14,5 +14,5 @@ export declare function generateWhereClause(where?: Dict): WhereClauseElement[];
 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, 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 declare function getSearchableQuery(q: QueryInput<string, any, any>): import('./types/find').SelectObject<string, any, any, 10>;
 export {};

package/dist/client/index.d.ts

@@ -2,8 +2,8 @@ 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';
+import { InterfaceMap, ExportFormat } from './types';
+import { Dump, DumpOptions } from './dump';
 export declare class DbClient<Name extends string, ModelNames extends string, Models extends CollectionObject<ModelNames>> {
     private readonly db;
     private readonly models;
@@ -15,8 +15,8 @@ export declare class DbClient<Name extends string, ModelNames extends string, Mo
     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>;
+    drop(): Promise<void>;
+    dump<const Format extends ExportFormat>(format: Format, stores?: ModelNames[], options?: DumpOptions): Promise<Dump<Format>>;
     deleteAllStores(): void;
     deleteStore(storeNames: Arrayable<ModelNames>): void;
     getModel<N extends ModelNames>(name: N): Models[N];

package/dist/client/restore.d.ts

@@ -0,0 +1,14 @@
+import { DbClient } from '.';
+import { ValidKey } from '../field';
+import { CollectionObject } from '../model';
+import { Transaction } from '../transaction';
+import { Dict } from '../util-types';
+/**
+ * Pushes the data found in the data parameter to the given store
+ * @param db Database client instance
+ * @param store Name of the store to add to
+ * @param data Data object, where each key-value pair is a primary key and its document
+ * @param primaryKeys Map of all primary keys of other stores (and this one) that were included within the source file
+ * @param tx Transaction object
+ */
+export declare function pushStoreData<Current extends Names, Names extends string>(db: DbClient<string, Names, CollectionObject<Names>>, store: Current, data: Dict, primaryKeys: Map<Names, Set<ValidKey>>, tx?: Transaction<"readwrite", Names>): Promise<void>;

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

@@ -1,29 +1,45 @@
-import { Dict, If, Keyof, MakeRequired, NoUndefined, RemoveNeverValues, Simplify } from '../../util-types.js';
-import { ExtractFields, ModelStructure, RelationlessModelStructure, RelationValue } from '../../model/model-types';
+import { Dec, Dict, Keyof, MakeRequired, NoUndefined, RecursionLimit, RemoveNeverValues, Simplify } from '../../util-types';
+import { ModelStructure, RelationlessModelStructure, RelationValue } from '../../model/model-types';
 import { Model, CollectionObject } from '../../model';
-import { BaseRelation, AbstractProperty, PrimaryKey, RelationOutputStructure, ValidValue, Relation } from '../../field';
+import { BaseRelation, PrimaryKey, RelationOutputStructure, ValidValue, Relation, Property } 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 Date ? Date : T extends object ? never : T;
+type ModelFields<C, K extends keyof C> = C[K] extends Model<any, infer Fields, any> ? Fields : never;
 export type WhereObject<Fields extends Dict<ValidValue>> = Partial<RemoveNeverValues<{
-    [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;
+    [K in keyof Fields]: Fields[K] extends Property<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;
+export type SelectObject<All extends string, Fields extends Dict<ValidValue>, C extends CollectionObject<All>, Depth extends number> = {
+    [K in keyof Fields]?: Fields[K] extends Property<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, Depth> : never : never) : never;
 };
-export interface QueryInput<All extends string, Fields extends Dict<ValidValue>, C extends CollectionObject<All>> {
+export interface QueryInput<All extends string, Fields extends Dict<ValidValue>, C extends CollectionObject<All>, Depth extends number = RecursionLimit> {
     where?: WhereObject<Fields>;
-    select?: SelectObject<All, Fields, C>;
-    include?: SelectObject<All, Fields, C>;
+    select?: SelectObject<All, Fields, C, Depth>;
+    include?: SelectObject<All, Fields, C, Depth>;
 }
-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 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;
+export type FindInput<All extends string, To extends keyof C, C extends CollectionObject<All>, Depth extends number = RecursionLimit> = Depth extends 0 ? never : QueryInput<All, ModelFields<C, To>, C, Dec<Depth>>;
+type NormalizeQuery<F> = F extends {
+    select: infer S;
+} ? {
+    mode: "select";
+    value: S;
+} : F extends {
+    include: infer I;
+} ? {
+    mode: "include";
+    value: I;
+} : {
+    mode: "none";
+    value: any;
 };
-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;
+type _SelectOutput<All extends string, Select extends Dict<Dict | true>, Fields extends Dict<ValidValue>, C extends CollectionObject<All>, Depth extends number> = {
+    [K in Keyof<Select>]: Fields[K] extends BaseRelation<infer To, any> ? To extends keyof C ? Select[K] extends true ? RelationOutputStructure<Fields[K], RelationlessModelStructure<C[To]>> : Select[K] extends FindInput<All, To, C, Depth> ? RelationOutputStructure<Fields[K], FindOutput<All, To, C, Select[K]>> : never : never : Fields[K] extends PrimaryKey<any, infer Type> ? Type : Fields[K] extends Property<infer Type, any> ? Type : never;
+};
+type _IncludeOutput<All extends string, Include extends Record<Keys, Dict | true>, Fields extends Dict<ValidValue>, C extends CollectionObject<All>, Depth extends number, Keys extends Keyof<Fields> = Keyof<Fields>> = {
+    [K in Keys]: Fields[K] extends BaseRelation<infer To, any> ? To extends keyof C ? Include[K] extends true ? RelationOutputStructure<Fields[K], RelationlessModelStructure<C[To]>> : Include[K] extends FindInput<All, To, C, Depth> ? MakeRequired<Fields[K] extends Relation<any, any> ? true : false, NoUndefined<RelationOutputStructure<Fields[K], NoUndefined<FindOutput<All, To, C, Include[K]>>>>> : unknown : RelationOutputStructure<Fields[K], RelationValue<To, C>> : Fields[K] extends PrimaryKey<any, infer Type> ? Type : Fields[K] extends Property<infer Type, any> ? Type : never;
+};
+type _OutputFromQuery<Q extends NormalizeQuery<any>, Fields extends Dict<ValidValue>, All extends string, C extends CollectionObject<All>, Depth extends number> = Q["mode"] extends "none" ? ModelStructure<Fields, C> : Q["mode"] extends "select" ? _SelectOutput<All, Q["value"], Fields, C, Depth> : Q["mode"] extends "include" ? _IncludeOutput<All, Q["value"], Fields, C, Depth> : never;
+export type FindOutput<All extends string, Name extends keyof C, C extends CollectionObject<All>, FIn extends FindInput<All, Name, C>, Depth extends number = RecursionLimit> = Depth extends 0 ? unknown : C[Name] extends Model<any, infer Fields, any> ? Simplify<_OutputFromQuery<NormalizeQuery<FIn>, Fields, All, C, Dec<Depth>>> | undefined : never;
 export {};

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

@@ -1,28 +1,28 @@
 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 { FindInput, FindOutput, WhereObject } from './find.js';
 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';
+import { Dump } from '../dump.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 type ExportFormat = "json" | "csv";
 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<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>>;
+    find<T extends FindInput<Names, Name, C>>(query: T, transaction?: Transaction<IDBTransactionMode, Names>): Promise<NonNullable<FindOutput<Names, Name, C, T>>[]>;
+    findFirst<T extends FindInput<Names, Name, C>>(query: T, transaction?: Transaction<IDBTransactionMode, Names>): Promise<FindOutput<Names, Name, C, T>>;
     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>;
-    compileQuery<T extends FindInput<Names, C[Name], C>>(query: T): CompiledQuery<Names, C, DbClient<string, Names, C>, T>;
+    compileQuery<T extends FindInput<Names, Name, C>>(query: T): CompiledQuery<Names, C, DbClient<string, Names, C>, T>;
     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>;
+    dump<Format extends ExportFormat>(format: Format, where?: WhereObject<C[Name] extends Model<any, infer Fields, any> ? Fields : never>): Promise<Dump<Format>>;
 }
 export type InterfaceMap<Names extends string, C extends CollectionObject<Names>> = {
     [K in Names]: Simplify<StoreInterface<K, Names, C>>;

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

@@ -1,49 +1,50 @@
-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 { MakeArrayable, MakeOptional, RemoveNeverValues, PartialOnUndefined, Extends, If, Or, Keyof } from '../../util-types';
+import { BaseRelation, Property, OptionalRelation, PrimaryKey, ArrayRelation } from '../../field';
+import { WhereObject } from './find';
 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>;
+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>, Value = RelationValue<To, C>, Dest extends C[To] = C[To]> = MakeOptional<IsNullable, MakeArrayable<IsArray, {
+    $connect: Value;
 } | {
-    $create: Omit<AddMutation<To, All, C[To], C>, OmitKeys | FindRelationKey<This, Name, C[To]>>;
+    $create: Omit<AddMutation<To, All, Dest, C>, OmitKeys | FindRelationKey<This, Name, Dest>>;
 } | {
-    $update: If<IsArray, UpdateMutation<To, All, C[To], C, OmitKeys | ThisKey>, Omit<UpdateMutation<To, All, C[To], C>["data"], OmitKeys>>;
+    $update: If<IsArray, UpdateMutation<To, All, Dest, C, OmitKeys | ThisKey>, Omit<UpdateMutation<To, All, Dest, C>["data"], OmitKeys>>;
 } | If<IsNullable, {
-    $delete: If<IsArray, RelationValue<To, C>, true>;
+    $delete: If<IsArray, Value, true>;
 } | {
-    $disconnect: If<IsArray, RelationValue<To, C>, true>;
+    $disconnect: If<IsArray, Value, true>;
 }, never>> | If<IsArray, {
-    $connectMany: RelationValue<To, C>[];
+    $connectMany: Value[];
 } | {
-    $createMany: Omit<AddMutation<To, All, C[To], C>, OmitKeys | FindRelationKey<This, Name, C[To]>>[];
+    $createMany: Omit<AddMutation<To, All, Dest, C>, OmitKeys | FindRelationKey<This, Name, Dest>>[];
 } | {
-    $updateMany: UpdateMutation<To, All, C[To], C, OmitKeys | ThisKey>[];
+    $updateMany: UpdateMutation<To, All, Dest, C, OmitKeys | ThisKey>[];
 } | {
-    $deleteMany: RelationValue<To, C>[];
+    $deleteMany: Value[];
 } | {
     $deleteAll: true;
 } | {
-    $disconnectMany: RelationValue<To, C>[];
+    $disconnectMany: Value[];
 } | {
     $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;
+        [K in Exclude<Keyof<Fields>, OmitKeys>]: Fields[K] extends Property<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>>;
 };
+type AddMutationRelation<This extends All, All extends string, C extends CollectionObject<All>, To extends All, RelationName extends string, Relation extends BaseRelation<any, any>, IsArray extends boolean = Extends<Relation, ArrayRelation<any, any>>, Value = RelationValue<To, C>> = MakeOptional<Or<IsArray, Extends<Relation, OptionalRelation<any, any>>>, MakeArrayable<IsArray, {
+    $connect: Value;
+} | {
+    $create: Omit<AddMutation<To, All, C[To], C>, FindRelationKey<This, RelationName, C[To]>>;
+}> | If<IsArray, {
+    $connectMany: Value[];
+} | {
+    $createMany: Omit<AddMutation<To, All, C[To], C>, FindRelationKey<This, RelationName, C[To]>>[];
+}, 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<AddMutation<To, All, C[To], C>, FindRelationKey<This, Name, C[To]>>;
-    }> | (Fields[K] extends ArrayRelation<any, any> ? {
-        $connectMany: RelationValue<To, C>[];
-    } | {
-        $createMany: Omit<AddMutation<To, All, C[To], C>, FindRelationKey<This, Name, C[To]>>[];
-    } : never)> : never : never;
+    [K in keyof Fields]: Fields[K] extends Property<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 ? AddMutationRelation<This, All, C, To, Name, Fields[K]> : never : never;
 } : never>>;
 export {};

package/dist/core.d.ts

@@ -1,14 +1,10 @@
-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, CollectionObject, ModelStructure, PrimaryKeyType, } 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';
 export type { FindInput, FindOutput } from './client/types/find';
 export type * from './client/types';
-export * as Typing from './field/type-wrapper';
+export * from './typing';

package/dist/error.d.ts

@@ -6,7 +6,7 @@ export type ErrorType = "ID_EXISTS" | "INVALID_ITEM" | "ADD_FAILED" | "UPDATE_FA
 /**
  * The database is not found
  */
- | "NO_DB" | "CUSTOM" | "INVALID_CONFIG" | "ASSERTION_FAILED" | "OPEN_CURSOR" | "UNKNOWN";
+ | "NO_DB" | "CUSTOM" | "INVALID_CONFIG" | "ASSERTION_FAILED" | "IMPORT_FAILED" | "OPEN_CURSOR" | "SERIALIZATION_FAILED" | "DESERIALIZATION_FAILED" | "UNKNOWN";
 export declare class StoreError extends Error {
     readonly code: ErrorType;
     constructor(code: ErrorType, message: string);
@@ -221,3 +221,48 @@ export declare const ExportError: {
     prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
     stackTraceLimit: number;
 };
+export declare const ImportError: {
+    new (message?: string): {
+        readonly code: ErrorType;
+        name: string;
+        message: string;
+        stack?: string;
+        cause?: unknown;
+    };
+    readonly code: "IMPORT_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 SerializationError: {
+    new (message?: string): {
+        readonly code: ErrorType;
+        name: string;
+        message: string;
+        stack?: string;
+        cause?: unknown;
+    };
+    readonly code: "SERIALIZATION_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 DeserializationError: {
+    new (message?: string): {
+        readonly code: ErrorType;
+        name: string;
+        message: string;
+        stack?: string;
+        cause?: unknown;
+    };
+    readonly code: "DESERIALIZATION_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/field-types.d.ts

@@ -1,8 +1,8 @@
 import { Dict } from '../util-types.js';
 import { default as PrimaryKey } from './primary-key.js';
-import { AbstractProperty, ParseFn, Property } from './property.js';
+import { ParseFn, Property } from './property.js';
 import { BaseRelation, OptionalRelation, ArrayRelation } from './relation.js';
-import { DateTag, NumberTag, StringTag } from './type-wrapper.js';
+import { DateTag, NumberTag, StringTag } from '../typing';
 export type ValidKey = string | number | Date;
 export type StringValidKeyType = "string" | "date" | "number";
 export type ValidKeyType = StringTag | DateTag | NumberTag;
@@ -21,7 +21,7 @@ export declare const enum FieldTypes {
     PrimaryKey = 2,
     Invalid = 3
 }
-export type GenFunction<T extends ValidKey> = () => T;
+export type GenFunction<T extends ValidKey> = (...args: unknown[]) => 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 {
@@ -29,8 +29,8 @@ export interface FieldOptions {
 }
 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 | null : 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 NonRelationOutput<T> = T extends Property<infer Out, any> ? Out : T extends PrimaryKey<any, infer Type> ? Type : never;
+export type ValidValue<N extends string = string> = BaseRelation<N, string> | Property<any, any> | PrimaryKey<boolean, ValidKey>;
 export type ParseFnWrap<T extends Dict> = {
     [K in keyof T]: ParseFn<T[K]>;
 };

package/dist/field/index.d.ts

@@ -3,4 +3,4 @@ export { PrimaryKey };
 export * from './relation.js';
 export * from './field-types.js';
 export * from './property.js';
-export * from './type-wrapper.js';
+export * from '../typing';