@idb-orm/core 1.0.3 → 1.0.5

package/LICENSE

@@ -0,0 +1,7 @@
+ISC License
+
+Copyright 2025 jtb
+
+Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted, provided that the above copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

package/README.md

@@ -1,5 +1,9 @@
 # IDB-ORM
 
+> 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
+
 ## Roadmap
 
 -   [x] "Include" query field

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

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

package/dist/client/delete.d.ts

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

package/dist/client/helpers.d.ts

@@ -1,9 +1,8 @@
-import type { Dict } from "../types/common.js";
+import type { Dict, Promisable } 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>;

package/dist/client/index.d.ts

@@ -1,12 +1,8 @@
-import type { Arrayable } from "type-fest";
 import type { CollectionObject, CompiledDb } from "../builder";
+import type { Arrayable } from "../types/common";
 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>
-> {
+import { type InterfaceMap } from "./types";
+export declare class DbClient<Name extends string, ModelNames extends string, Models extends CollectionObject<ModelNames>> {
     private readonly db;
     private readonly models;
     readonly name: Name;
@@ -14,14 +10,7 @@ export declare class DbClient<
     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>;
+    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;
@@ -30,23 +19,6 @@ export declare class DbClient<
     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

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

@@ -1,107 +1,23 @@
 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";
+import type { ExtractFields, ModelStructure, RelationlessModelStructure } from "../../model/model-types.js";
+import type { Model } from "../../model";
+import type { BaseRelation, Field, PrimaryKey, RelationOutputStructure, ValidValue } from "../../field";
+import type { CollectionObject } from "../../builder.ts";
 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 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>
-> {
+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 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

@@ -1,58 +1,22 @@
-import type { CollectionObject } from "../../builder";
+import type { CollectionObject } from "../../builder.ts";
 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 type { ExtractFields, Model, ModelStructure, PrimaryKeyType } from "../../model";
+import type { AddMutation, UpdateMutation } from "./mutation.ts";
+import type { FindInput, FindOutput, WhereObject } from "./find.ts";
+import type { CompiledQuery } from "../compiled-query.ts";
+import type { DbClient } from "../index.ts";
 import { Transaction } from "../../transaction.js";
-import { BaseRelation } from "../../field/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>>;
+import { BaseRelation } from "../../field";
+export type InsertMutation<N extends string, C extends Dict> = C[N] extends Model<N, infer F, any> ? ModelStructure<F, C> : never;
+export interface StoreInterface<Name extends Names, Names extends string, C extends CollectionObject<Names>, KeyType = PrimaryKeyType<C[Name]>, Add = AddMutation<Name, Names, C[Name], C>, Update = UpdateMutation<Name, Names, C[Name], C>> {
+    add(mutation: Add, transaction?: Transaction<"readwrite", Names>): Promise<KeyType>;
+    addMany(mutations: Add[], transaction?: Transaction<"readwrite", Names>): Promise<KeyType[]>;
+    find<T extends FindInput<Names, C[Name], C>>(query: T, transaction?: Transaction<IDBTransactionMode, Names>): Promise<FindOutput<Names, C[Name], C, T>[]>;
+    findFirst<T extends FindInput<Names, C[Name], C>>(query: T, transaction?: Transaction<IDBTransactionMode, Names>): Promise<FindOutput<Names, C[Name], C, T>>;
     put(): Promise<void>;
-    insert(
-        item: InsertMutation<Name, C>,
-        transaction?: Transaction<"readwrite", Names>
-    ): Promise<KeyType>;
-    updateFirst(
-        item: Update,
-        transaction?: Transaction<"readwrite", Names>
-    ): Promise<KeyType | undefined>;
-    updateMany(
-        item: Update,
-        transaction?: Transaction<"readwrite", Names>
-    ): Promise<KeyType[]>;
+    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>;
@@ -60,39 +24,39 @@ export interface StoreInterface<
      * 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>;
+    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>
-> = {
+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 declare const enum MutationBreath {
+    Find = 0,
+    Singleton = 1
+}
+export interface MutationState<Names extends string> extends Partial<{
+    tx: Transaction<"readwrite", Names>;
+    relation: {
+        id: ValidKey;
+        key: string;
+    };
+    singleton: {
+        id: ValidKey;
+    };
+    finalStep: boolean;
+}> {
+}
 export type KeyObject<Index = string> = {
     isFun: boolean;
     key: Index;
-} & (
-    | {
-          isRelation: true;
-          relation: BaseRelation<any, any>;
-      }
-    | {
-          isRelation: false;
-          relation?: undefined;
-      }
-);
+} & ({
+    isRelation: true;
+    relation: BaseRelation<any, any>;
+} | {
+    isRelation: false;
+    relation?: undefined;
+});
 export type { AddMutation, UpdateMutation };