@idb-orm/core 1.0.3

package/README.md

@@ -0,0 +1,38 @@
+# IDB-ORM
+
+## Roadmap
+
+-   [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
+-   [ ] 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
+-   [ ] Remove external dependencies
+    -   [ ] deep-equal
+    -   [x] type-fest
+    -   [ ] uuid
+    -   [ ] zod
+-   [ ] Make subpackages for adapters for different validation languages
+    -   [ ] Zod
+    -   [ ] Yup
+    -   [ ] Joi
+    -   [ ] schema.js
+
+### Roadmap - Maybe
+
+-   [ ] 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

@@ -0,0 +1,25 @@
+import { Model, type CollectionZodSchema } from "./model";
+import { DbClient } from "./client";
+import { PrimaryKey, type ValidValue } from "./field";
+import type { Dict } from "./types/common";
+export type CollectionObject<Names extends string> = {
+    [K in Names]: Model<K, any>;
+};
+export declare class Builder<Name extends string, Names extends string> {
+    readonly name: Name;
+    readonly names: Names[];
+    private models;
+    constructor(name: Name, names: Names[]);
+    defineModel<N extends Names, T extends Dict<ValidValue<Names>>>(name: N, values: T): Model<N, T, Extract<{ [K in keyof T]: T[K] extends PrimaryKey<any, any> ? K : never; }[keyof T], string>>;
+    compile<M extends CollectionObject<Names>>(models: M): CompiledDb<Name, Names, M>;
+}
+export declare class CompiledDb<Name extends string, Names extends string, C extends CollectionObject<Names>> {
+    readonly name: Name;
+    private readonly models;
+    readonly schemas: CollectionZodSchema<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,23 @@
+import type { CollectionObject } from "../builder";
+import type { DbClient } from "./index";
+import type { 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, 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/helpers.d.ts

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

package/dist/client/index.d.ts

@@ -0,0 +1,61 @@
+import type { Arrayable } from "type-fest";
+import type { CollectionObject, CompiledDb } from "../builder";
+import { Transaction, type TransactionOptions } from "../transaction";
+import type { InterfaceMap } from "./types/index";
+export declare class DbClient<
+    Name extends string,
+    ModelNames extends string,
+    Models extends CollectionObject<ModelNames>
+> {
+    private readonly db;
+    private readonly models;
+    readonly name: Name;
+    readonly version: number;
+    readonly stores: InterfaceMap<ModelNames, Models>;
+    constructor(db: IDBDatabase, models: CompiledDb<Name, ModelNames, Models>);
+    getStore<Name extends ModelNames>(name: Name): (typeof this.stores)[Name];
+    createTransaction<
+        Mode extends IDBTransactionMode,
+        Names extends ModelNames
+    >(
+        mode: Mode,
+        stores: Arrayable<Names>,
+        options?: TransactionOptions
+    ): Transaction<Mode, Names>;
+    deleteDb(): Promise<void>;
+    deleteAllStores(): void;
+    deleteStore(storeNames: Arrayable<ModelNames>): void;
+    getModel<N extends ModelNames>(name: N): Models[N];
+    private getAccessedStores;
+    private createInterface;
+    private add;
+    private clear;
+    /**
+     * Deletes a single document from a store given its Primary key value
+     * @param name Name of the store
+     * @param key Primary key value
+     * @param _state Optional state for multi-stage actions
+     * @returns Boolean indicating whether or not an item was removed
+     */
+    private deleteSingleton;
+    /**
+     * Deletes documents from the store that match the given filter.
+     * @param name Name of the store
+     * @param where Optional filter
+     * @param stopOnFirst Flag to stop after one successful deletion
+     * @param _state Optional state for multi-stage actions
+     * @returns The number of documents deleted
+     */
+    private delete;
+    /**
+     * Finds documents from the store that match the filter
+     * @param name Name of the store
+     * @param item Object containing the filter and the selection query
+     * @param stopOnFirst Flag to stop after one successful find
+     * @param _state Optional state for mutli-stage actions
+     * @returns Transformed selection item
+     */
+    private find;
+    private update;
+    private updateSingleton;
+}

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

@@ -0,0 +1,107 @@
+import type { Dict, If, Keyof, RemoveNeverValues } from "../../types/common.js";
+import type {
+    ExtractFields,
+    ModelStructure,
+    RelationlessModelStructure,
+} from "../../model/model-types.js";
+import type { Model } from "../../model/index";
+import type {
+    BaseRelation,
+    Field,
+    PrimaryKey,
+    RelationOutputStructure,
+    ValidValue,
+} from "../../field/index";
+import type { CollectionObject } from "../../builder";
+export type FilterFn<Input> = (item: Input) => boolean;
+export type WhereObject<Fields extends Dict<ValidValue>> = Partial<
+    RemoveNeverValues<{
+        [K in keyof Fields]: Fields[K] extends Field<infer Output, any>
+            ? Output | FilterFn<Output>
+            : Fields[K] extends PrimaryKey<any, infer Type>
+            ? 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 Field<any, any>
+        ? true
+        : Fields[K] extends PrimaryKey<any, any>
+        ? true
+        : Fields[K] extends BaseRelation<infer To, any>
+        ?
+              | true
+              | (To extends Keyof<C>
+                    ? C[To] extends Model<any, infer SubFields, any>
+                        ? QueryInput<All, SubFields, C>
+                        : never
+                    : never)
+        : never;
+};
+export interface QueryInput<
+    All extends string,
+    Fields extends Dict<ValidValue>,
+    C extends CollectionObject<All>
+> {
+    where?: WhereObject<Fields>;
+    select?: SelectObject<All, Fields, C>;
+    include?: SelectObject<All, Fields, C>;
+}
+export type FindInput<
+    All extends string,
+    Struct extends object,
+    C extends CollectionObject<All>
+> = Struct extends Model<any, infer Fields, any>
+    ? QueryInput<All, Fields, C>
+    : never;
+type _FindOutput<
+    All extends string,
+    Select extends Dict<Dict | true>,
+    Fields extends Dict<ValidValue>,
+    C extends CollectionObject<All>
+> =
+    | {
+          [K in Keyof<Select>]: Fields[K] extends BaseRelation<infer To, any>
+              ? To extends Keyof<C>
+                  ? C[To] extends Model<any, infer Sub, any>
+                      ? If<
+                            Select[K] extends true ? true : false,
+                            RelationOutputStructure<
+                                Fields[K],
+                                RelationlessModelStructure<C[To]>
+                            >,
+                            Select[K] extends Dict<Dict | true>
+                                ? RelationOutputStructure<
+                                      Fields[K],
+                                      _FindOutput<All, Select[K], Sub, C>
+                                  >
+                                : never
+                        >
+                      : never
+                  : never
+              : Fields[K] extends PrimaryKey<any, infer Type>
+              ? Type
+              : Fields[K] extends Field<infer Type, any>
+              ? Type
+              : never;
+      }
+    | undefined;
+export type FindOutput<
+    All extends string,
+    Struct extends Model<any, any, any>,
+    C extends CollectionObject<All>,
+    F extends FindInput<All, Struct, C>
+> = Struct extends Model<any, infer Fields, any>
+    ? F extends object
+        ?
+              | (F["select"] extends Dict<true | Dict>
+                    ? _FindOutput<All, F["select"], Fields, C>
+                    : ModelStructure<ExtractFields<Struct>, C>)
+              | undefined
+        : never
+    : never;
+export {};

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

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

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

@@ -0,0 +1,225 @@
+import type {
+    MakeArrayable,
+    MakeOptional,
+    RemoveNeverValues,
+    PartialOnUndefined,
+} from "../../types/common.js";
+import type {
+    BaseRelation,
+    Field,
+    OptionalRelation,
+    PrimaryKey,
+    RelationArray,
+} from "../../field/index";
+import type { CollectionObject } from "../../builder";
+import { WhereObject } from "./find.js";
+import { Model, FindRelationKey, RelationValue } from "../../model/index";
+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 Field<
+                      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 RelationArray<any, any>
+                                    ? true
+                                    : MutType extends "update"
+                                    ? true
+                                    : false,
+                                | MakeArrayable<
+                                      Fields[K] extends RelationArray<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 RelationArray<
+                                                            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 RelationArray<
+                                                            any,
+                                                            any
+                                                        >
+                                                            ? RelationValue<
+                                                                  To,
+                                                                  C
+                                                              >
+                                                            : true;
+                                                    }
+                                                  | {
+                                                        $disconnect: Fields[K] extends RelationArray<
+                                                            any,
+                                                            any
+                                                        >
+                                                            ? RelationValue<
+                                                                  To,
+                                                                  C
+                                                              >
+                                                            : true;
+                                                    }
+                                            : never)
+                                  >
+                                | (Fields[K] extends RelationArray<any, any>
+                                      ?
+                                            | {
+                                                  $connectMany: RelationValue<
+                                                      To,
+                                                      C
+                                                  >[];
+                                              }
+                                            | {
+                                                  $createMany: Omit<
+                                                      Mutation<
+                                                          To,
+                                                          All,
+                                                          C[To],
+                                                          C,
+                                                          "add"
+                                                      >,
+                                                      FindRelationKey<
+                                                          This,
+                                                          Name,
+                                                          C[To]
+                                                      >
+                                                  >[];
+                                              }
+                                            | {
+                                                  $updateMany: {
+                                                      where?: WhereSelection<
+                                                          C[To]
+                                                      >;
+                                                      data: Mutation<
+                                                          To,
+                                                          All,
+                                                          C[To],
+                                                          C,
+                                                          MutType
+                                                      >;
+                                                  }[];
+                                              }
+                                            | {
+                                                  $deleteMany: RelationValue<
+                                                      To,
+                                                      C
+                                                  >[];
+                                              }
+                                            | {
+                                                  $deleteAll: true;
+                                              }
+                                            | {
+                                                  $disconnectMany: RelationValue<
+                                                      To,
+                                                      C
+                                                  >[];
+                                              }
+                                            | {
+                                                  $disconnectAll: true;
+                                              }
+                                      : never)
+                            >
+                          : never
+                      : never;
+              }
+            : never
+    >
+>;
+export type AddMutation<
+    This extends All,
+    All extends string,
+    Struct extends object,
+    C extends CollectionObject<All>
+> = Mutation<This, All, Struct, C, "add">;
+export interface UpdateMutation<
+    This extends All,
+    All extends string,
+    Struct extends object,
+    C extends CollectionObject<All>
+> {
+    where?: WhereSelection<Struct>;
+    data: Mutation<This, All, Struct, C, "update">;
+}
+type WhereSelection<Struct extends object> = Struct extends Model<
+    any,
+    infer Fields,
+    any
+>
+    ? WhereObject<Fields>
+    : never;
+export {};