@idb-orm/core 1.0.8 → 1.0.9

package/dist/builder.d.ts

@@ -0,0 +1,23 @@
+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>>>(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>> {
+    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

@@ -0,0 +1,13 @@
+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;
+    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

@@ -0,0 +1,13 @@
+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
+ * @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

@@ -0,0 +1,18 @@
+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, 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

@@ -0,0 +1,59 @@
+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;
+    readonly name: Name;
+    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];
+    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;
+    /**
+     * 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

@@ -0,0 +1,29 @@
+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 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> ? 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 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 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

@@ -0,0 +1,63 @@
+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<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>>;
+    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>;
+    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>;
+};
+export interface QueryState<Names extends string> {
+    tx?: Transaction<IDBTransactionMode, Names>;
+}
+export interface MutationState<Names extends string> extends Partial<{
+    tx: Transaction<"readwrite", Names>;
+    relation: {
+        id: ValidKey;
+        key: string;
+    };
+    singleton: {
+        id: ValidKey;
+    };
+    /**
+     * Flag indicating whether or not this is the final step of the query/mutation
+     * @default true
+     */
+    finalStep: 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

@@ -0,0 +1,49 @@
+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<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;
+} : 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

@@ -0,0 +1,223 @@
+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
+ */
+ | "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;
+    constructor(code: ErrorType, message: string);
+}
+export declare const InvalidConfigError: {
+    new (message?: string): {
+        readonly code: ErrorType;
+        name: string;
+        message: 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;
+        name: string;
+        message: 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;
+        name: string;
+        message: 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;
+        name: string;
+        message: 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;
+        name: string;
+        message: 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;
+        name: string;
+        message: 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;
+        name: string;
+        message: 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;
+        name: string;
+        message: 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;
+        name: string;
+        message: 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;
+        name: string;
+        message: 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;
+        name: string;
+        message: 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;
+        name: string;
+        message: 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;
+};
+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;
+};

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

@@ -0,0 +1,37 @@
+import { Dict } from '../util-types.js';
+import { default as PrimaryKey } from './primary-key.js';
+import { AbstractProperty, ParseFn, Property } from './property.js';
+import { BaseRelation, OptionalRelation, ArrayRelation } from './relation.js';
+import { DateTag, NumberTag, StringTag } from './type-wrapper.js';
+export type ValidKey = string | number | Date;
+export type StringValidKeyType = "string" | "date" | "number";
+export type ValidKeyType = StringTag | DateTag | NumberTag;
+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 {
+    Property = 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 | 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 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;

package/dist/field/index.d.ts

@@ -0,0 +1,6 @@
+import { default as PrimaryKey } from './primary-key.js';
+export { PrimaryKey };
+export * from './relation.js';
+export * from './field-types.js';
+export * from './property.js';
+export * from './type-wrapper.js';

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

@@ -0,0 +1,23 @@
+import { GenFunction, ValidKey, ValidKeyType } from './field-types.js';
+export default class PrimaryKey<AutoGenerate extends boolean, KeyType extends ValidKey> {
+    readonly symbol: symbol;
+    private genFn?;
+    private autoGenerate;
+    readonly type: ValidKeyType;
+    constructor();
+    constructor(type: ValidKeyType);
+    constructor(type: ValidKeyType, generator: GenFunction<KeyType>);
+    getType(): ValidKeyType;
+    generator(genFn: GenFunction<KeyType>): PrimaryKey<true, KeyType>;
+    autoIncrement(): PrimaryKey<true, number>;
+    uuid(): PrimaryKey<true, string>;
+    date(): PrimaryKey<true, Date>;
+    genKey(): KeyType;
+    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;
+    static is(value: object): value is PrimaryKey<any, any>;
+}