@idb-orm/core 1.0.4 → 1.0.6

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

@@ -1,6 +1,6 @@
 import { CompiledDb } from "../builder.js";
-import { BaseRelation, Field, OptionalRelation, PrimaryKey, Relation, RelationArray, RelationOutput, ValidValue } from "../field";
-import { Dict, Keyof, ZodWrap } from "../types/common.js";
+import { ValidValue, BaseRelation, OptionalRelation, ArrayRelation, RelationOutput, Relation, AbstractProperty, PrimaryKey, ParseFnWrap } from "../field";
+import { Dict, Keyof } from "../util-types.js";
 import Model from "./model.js";
 export type FindPrimaryKey<F extends Record<string, ValidValue>> = Extract<{
     [K in keyof F]: F[K] extends PrimaryKey<any, any> ? K : never;
@@ -18,9 +18,9 @@ export type RelationValue<Name extends string, C> = Name extends keyof C ? C[Nam
 /**
  * Gets the primitive type of the relation field
  */
-export type GetRelationField<F, C> = F extends Relation<infer To, any> ? RelationValue<To, C> : F extends OptionalRelation<infer To, any> ? RelationValue<To, C> | undefined : F extends RelationArray<infer To, any> ? RelationValue<To, C>[] : never;
+export type GetRelationField<F, C> = F extends Relation<infer To, any> ? RelationValue<To, C> : F extends OptionalRelation<infer To, any> ? RelationValue<To, C> | undefined : F extends ArrayRelation<infer To, any> ? RelationValue<To, C>[] : never;
 export type ModelStructure<F extends Dict<ValidValue>, C> = {
-    [K in keyof F]: F[K] extends Field<infer Output, any> ? Output : F[K] extends PrimaryKey<any, infer Type> ? Type : GetRelationField<F[K], C>;
+    [K in keyof F]: F[K] extends AbstractProperty<infer Output, any> ? Output : F[K] extends PrimaryKey<any, infer Type> ? Type : GetRelationField<F[K], C>;
 };
 export type ModelType<M extends Model<any, any, any>, C extends CompiledDb<any, any, any>> = M extends Model<any, infer Fields, any> ? C extends CompiledDb<any, any, infer Collection> ? ModelStructure<Fields, Collection> : never : never;
 export type ExtractFields<M extends Model<any, any, any>> = M extends Model<any, infer Fields, any> ? Fields : never;
@@ -28,10 +28,10 @@ export type AllRelationKeys<M extends Model<any, any, any>> = M extends Model<an
     [K in Keyof<Fields>]: Fields[K] extends BaseRelation<any, any> ? K : never;
 }[Keyof<Fields>] : never;
 export type RelationlessModelStructure<M extends Model<any, any, any>> = M extends Model<any, infer Fields, any> ? Omit<{
-    [K in Keyof<Fields>]: Fields[K] extends BaseRelation<any, any> ? unknown : Fields[K] extends Field<infer Type, any> ? Type : Fields[K] extends PrimaryKey<any, infer Type> ? Type : never;
+    [K in Keyof<Fields>]: Fields[K] extends BaseRelation<any, any> ? unknown : Fields[K] extends AbstractProperty<infer Type, any> ? Type : Fields[K] extends PrimaryKey<any, infer Type> ? Type : never;
 }, AllRelationKeys<M>> : never;
-export type CollectionZodSchema<C> = C extends Record<infer Keys, Model<any, any, any>> ? {
-    [K in Keys]: C[K] extends Model<any, infer Fields, any> ? ZodWrap<ModelStructure<Fields, C>> : never;
+export type CollectionSchema<C> = C extends Record<infer Keys, Model<any, any, any>> ? {
+    [K in Keys]: C[K] extends Model<any, infer Fields, any> ? ParseFnWrap<ModelStructure<Fields, C>> : never;
 } : never;
 export type FindRelationKey<From extends string, RelationName extends string, M extends Model<any, any, any>> = M extends Model<any, infer Fields, any> ? {
     [K in Keyof<Fields>]: Fields[K] extends BaseRelation<From, infer CurName> ? CurName extends RelationName ? K : never : never;

package/dist/model/model.d.ts

@@ -1,8 +1,7 @@
-import z from "zod";
 import { CollectionObject } from "../builder.js";
 import { DbClient } from "../client/index.js";
-import { BaseRelation, Field, FieldTypes, PrimaryKey, ValidValue } from "../field";
-import { Keyof, ValidKey } from "../types/common.js";
+import { BaseRelation, AbstractProperty, FieldTypes, PrimaryKey, ValidValue, ParseResult } from "../field";
+import { Keyof, ValidKey } from "../util-types.js";
 import { FindPrimaryKey } from "./model-types.js";
 export default class Model<Name extends string, F extends Record<string, ValidValue>, Primary extends FindPrimaryKey<F> = FindPrimaryKey<F>> {
     readonly name: Name;
@@ -13,12 +12,12 @@ export default class Model<Name extends string, F extends Record<string, ValidVa
     readonly primaryKey: Primary;
     constructor(name: Name, fields: F);
     get<K extends Keyof<F>>(key: K): F[K];
-    getModelField(key: string): Field<any, any> | undefined;
+    getModelField(key: string): AbstractProperty<any, any> | undefined;
     getPrimaryKey(): PrimaryKey<boolean, ValidKey>;
     getRelation<Models extends string>(key: string): BaseRelation<Models, string> | undefined;
     keyType(key: Keyof<F>): FieldTypes;
     links<Names extends string = string>(): SetIterator<Names>;
     keys(): Keyof<F>[];
-    parseField<K extends Keyof<F>>(field: K, value: unknown): z.ZodSafeParseResult<any>;
+    parseField<K extends Keyof<F>>(field: K, value: unknown): ParseResult<any>;
     getDeletedStores<ModelNames extends string, Models extends CollectionObject<ModelNames>>(client: DbClient<string, ModelNames, Models>): Set<ModelNames>;
 }

package/dist/object-store.d.ts

@@ -3,7 +3,7 @@
  */
 import { StoreError } from "./error.js";
 import { Transaction } from "./transaction.js";
-import { Dict, Promisable, ValidKey } from "./types/common.js";
+import { Dict, Promisable, ValidKey } from "./util-types.js";
 export declare class ObjectStore {
     private readonly tx;
     readonly store: IDBObjectStore;

package/dist/transaction.d.ts

@@ -1,6 +1,6 @@
 import { StoreError } from "./error";
 import { ObjectStore } from "./object-store.js";
-import { Arrayable } from "./types/common.js";
+import { Arrayable } from "./util-types.js";
 export type TransactionStatus = "running" | "aborted" | "complete" | "error";
 export type TransactionEventHandler = (tx: Transaction<IDBTransactionMode>, ev: Event) => void;
 export interface TransactionOptions extends Partial<{

package/dist/tsconfig.tsbuildinfo

@@ -0,0 +1 @@
+{"root":["../src/builder.ts","../src/error.ts","../src/index.ts","../src/object-store.ts","../src/transaction.ts","../src/types.ts","../src/utils.ts","../src/client/compiled-query.ts","../src/client/delete.ts","../src/client/helpers.ts","../src/client/index.ts","../src/client/types/find.ts","../src/client/types/index.ts","../src/client/types/mutation.ts","../src/field/field-types.ts","../src/field/index.ts","../src/field/primary-key.ts","../src/field/property.ts","../src/field/relation.ts","../src/model/index.ts","../src/model/model-types.ts","../src/model/model.ts","../tests/helpers.ts","../tests/test.spec.ts"],"version":"5.9.3"}

package/dist/types/common.d.ts

@@ -1,4 +1,3 @@
-import type z from "zod";
 /**
  * Extracts the string keys of an object
  */
@@ -6,6 +5,18 @@ export type Keyof<T extends Record<any, any>> = Extract<keyof T, string>;
 export type Arrayable<T> = T | T[];
 export type IsNever<T> = [T] extends [never] ? true : false;
 export type Promisable<T> = T | Promise<T>;
+export type NoUndefined<T> = Exclude<T, undefined>;
+export declare enum Type {
+    String = 0,
+    Number = 1,
+    BigInt = 2,
+    Boolean = 3,
+    Symbol = 4,
+    Array = 5,
+    Date = 6,
+    Object = 7,
+    Unknown = 8
+}
 export type MakeOptional<B extends boolean, T> = B extends true ? T | undefined : T;
 export type MakeArray<B extends boolean, T> = B extends true ? T[] : T;
 export type MakeArrayable<B extends boolean, T> = B extends true ? Arrayable<T> : T;
@@ -23,9 +34,6 @@ export type ConnectionObject<M extends boolean = false, T = object, K = ValidKey
     $createMany: T[];
     $connectMany: K[];
 }, Dict>;
-export type ZodWrap<T extends Dict> = {
-    [K in keyof T]: z.ZodType<T[K]>;
-};
 type UndefinedKeys<T extends Dict> = {
     [K in Keyof<T>]: undefined extends T[K] ? K : never;
 }[Keyof<T>];

package/dist/types.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Extracts the string keys of an object
+ */
+export type Keyof<T extends Record<any, any>> = Extract<keyof T, string>;
+export type Arrayable<T> = T | T[];
+export type IsNever<T> = [T] extends [never] ? true : false;
+export type Promisable<T> = T | Promise<T>;
+export type NoUndefined<T> = Exclude<T, undefined>;
+export declare enum Type {
+    String = 0,
+    Number = 1,
+    BigInt = 2,
+    Boolean = 3,
+    Symbol = 4,
+    Array = 5,
+    Date = 6,
+    Object = 7,
+    Unknown = 8
+}
+export type MakeOptional<B extends boolean, T> = B extends true ? T | undefined : T;
+export type MakeArray<B extends boolean, T> = B extends true ? T[] : T;
+export type MakeArrayable<B extends boolean, T> = B extends true ? Arrayable<T> : T;
+export type ValidKey = string | number | Date;
+export type ValidKeyType = "string" | "number" | "date";
+export type If<Type extends boolean, IfBranch, ElseBranch> = IsNever<Type> extends true ? ElseBranch : Type extends true ? IfBranch : ElseBranch;
+export type RemoveNeverValues<T extends object> = {
+    [K in keyof T as T[K] extends never ? never : K]: T[K];
+};
+export type Dict<T = unknown> = Record<string, T>;
+export type ConnectionObject<M extends boolean = false, T = object, K = ValidKey> = {
+    $create: T;
+    $connect: K;
+} & If<M, {
+    $createMany: T[];
+    $connectMany: K[];
+}, Dict>;
+type UndefinedKeys<T extends Dict> = {
+    [K in Keyof<T>]: undefined extends T[K] ? K : never;
+}[Keyof<T>];
+type Optional<T extends Dict> = Partial<Pick<T, UndefinedKeys<T>>>;
+type Required<T extends Dict> = Omit<T, UndefinedKeys<T>>;
+export type PartialOnUndefined<T extends Dict> = Required<T> & Optional<T>;
+/**
+ * Types that can be resolved to specific boolean values
+ */
+export type BooleanLike = boolean | undefined | null | 0;
+export type Literable = string | number | bigint | boolean | null | undefined;
+export {};

package/dist/util-types.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Extracts the string keys of an object
+ */
+export type Keyof<T extends Record<any, any>> = Extract<keyof T, string>;
+export type Arrayable<T> = T | T[];
+export type IsNever<T> = [T] extends [never] ? true : false;
+export type Promisable<T> = T | Promise<T>;
+export type NoUndefined<T> = Exclude<T, undefined>;
+export type MakeOptional<B extends boolean, T> = B extends true ? T | undefined : T;
+export type MakeArray<B extends boolean, T> = B extends true ? T[] : T;
+export type MakeArrayable<B extends boolean, T> = B extends true ? Arrayable<T> : T;
+export type ValidKey = string | number | Date;
+export type ValidKeyType = "string" | "number" | "date";
+export type If<Type extends boolean, IfBranch, ElseBranch> = IsNever<Type> extends true ? ElseBranch : Type extends true ? IfBranch : ElseBranch;
+export type RemoveNeverValues<T extends object> = {
+    [K in keyof T as T[K] extends never ? never : K]: T[K];
+};
+export type Dict<T = unknown> = Record<string, T>;
+export type ConnectionObject<M extends boolean = false, T = object, K = ValidKey> = {
+    $create: T;
+    $connect: K;
+} & If<M, {
+    $createMany: T[];
+    $connectMany: K[];
+}, Dict>;
+type UndefinedKeys<T extends Dict> = {
+    [K in Keyof<T>]: undefined extends T[K] ? K : never;
+}[Keyof<T>];
+type Optional<T extends Dict> = Partial<Pick<T, UndefinedKeys<T>>>;
+type Required<T extends Dict> = Omit<T, UndefinedKeys<T>>;
+export type PartialOnUndefined<T extends Dict> = Required<T> & Optional<T>;
+/**
+ * Types that can be resolved to specific boolean values
+ */
+export type BooleanLike = boolean | undefined | null | 0;
+export type Literable = string | number | bigint | boolean | null | undefined;
+export {};

package/dist/utils.d.ts

@@ -1,9 +1,11 @@
-import type { Arrayable, Keyof } from "./types/common";
+import { Arrayable, Keyof, ValidKeyType } from "./util-types";
 import type { Transaction } from "./transaction.js";
 export declare function handleRequest<T>(req: IDBRequest<T>, tx?: Transaction<any, any>): Promise<T>;
 export declare function getKeys<T extends object>(obj: T): Keyof<T>[];
 export declare function addToSet<T>(set: Set<T>, items: T[]): Set<T>;
 export declare function toArray<T>(value: Arrayable<T>): T[];
+export declare function stringTypeToEnum(type: ValidKeyType): Type;
+export declare function uuid(): `${string}-${string}-${string}-${string}-${string}`;
 /**
  * Identity Function, it returns the first argument it is given, all others are ignored
  * @param value Value
@@ -14,3 +16,14 @@ export declare function identity<T>(value: T): T;
  * Performs a union over `set1` and `set2`, modifying `set1` to be union of the two sets
  */
 export declare function unionSets<T>(set: Set<T>, other: Set<T>): Set<T>;
+export declare enum Type {
+    String = 0,
+    Number = 1,
+    BigInt = 2,
+    Boolean = 3,
+    Symbol = 4,
+    Array = 5,
+    Date = 6,
+    Object = 7,
+    Unknown = 8
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@idb-orm/core",
-    "version": "1.0.4",
+    "version": "1.0.6",
     "description": "",
     "main": "dist/index.js",
     "type": "module",
@@ -10,9 +10,9 @@
         "check": "eslint . && tsc -b --noEmit",
         "test": "playwright test"
     },
-    "keywords": [],
-    "workspaces": [
-        "packages/*"
+    "keywords": [
+        "typescript",
+        "indexeddb"
     ],
     "author": "jtb",
     "exports": {
@@ -20,6 +20,9 @@
             "types": "./dist/index.d.ts",
             "import": "./dist/index.js",
             "require": "./dist/index.js"
+        },
+        "./types": {
+            "types": "./dist/dev-types.d.ts"
         }
     },
     "license": "ISC",
@@ -36,10 +39,5 @@
         "tslib": "^2.8.1",
         "typescript": "^5.9.3",
         "typescript-eslint": "^8.46.2"
-    },
-    "dependencies": {
-        "@gilbarbara/deep-equal": "^0.3.1",
-        "uuid": "^13.0.0",
-        "zod": "^4.1.3"
     }
 }

package/test-results/.last-run.json

@@ -0,0 +1,4 @@
+{
+  "status": "passed",
+  "failedTests": []
+}