@idb-orm/core 1.0.4 → 1.0.6

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

@@ -25,11 +25,11 @@
     -   [ ] findMany
     -   [ ] updateMany
 -   [ ] Convert internal string unions to enums
--   [ ] Remove external dependencies
-    -   [ ] deep-equal
+-   [x] Remove external dependencies
+    -   [x] deep-equal
     -   [x] type-fest
-    -   [ ] uuid
-    -   [ ] zod
+    -   [x] uuid
+    -   [x] zod
 -   [ ] Make subpackages for adapters for different validation languages
     -   [ ] Zod
     -   [ ] Yup

package/dist/builder.d.ts

@@ -1,7 +1,7 @@
-import { Model, type CollectionZodSchema } from "./model";
+import { CollectionSchema, Model } from "./model";
 import { DbClient } from "./client";
 import { PrimaryKey, type ValidValue } from "./field";
-import type { Dict } from "./types/common";
+import type { Dict } from "./util-types";
 export type CollectionObject<Names extends string> = {
     [K in Names]: Model<K, any>;
 };
@@ -16,7 +16,7 @@ export declare class Builder<Name extends string, Names extends string> {
 export declare class CompiledDb<Name extends string, Names extends string, C extends CollectionObject<Names>> {
     readonly name: Name;
     private readonly models;
-    readonly schemas: CollectionZodSchema<C>;
+    readonly schemas: CollectionSchema<C>;
     private readonly modelKeys;
     constructor(name: Name, models: C);
     getModel<N extends Names>(name: N): C[N];

package/dist/client/helpers.d.ts

@@ -1,4 +1,4 @@
-import type { Dict, Promisable } from "../types/common.js";
+import type { Dict, Promisable } from "../util-types.js";
 import type { DbClient } from "./index.ts";
 import type { CollectionObject } from "../builder.ts";
 import type { QueryInput } from "./types/find.ts";

package/dist/client/index.d.ts

@@ -1,5 +1,5 @@
 import type { CollectionObject, CompiledDb } from "../builder";
-import type { Arrayable } from "../types/common";
+import type { Arrayable } from "../util-types";
 import { Transaction, type TransactionOptions } from "../transaction";
 import { type InterfaceMap } from "./types";
 export declare class DbClient<Name extends string, ModelNames extends string, Models extends CollectionObject<ModelNames>> {

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

@@ -1,14 +1,18 @@
-import type { Dict, If, Keyof, RemoveNeverValues } from "../../types/common.js";
+import type { Dict, If, Keyof, RemoveNeverValues } from "../../util-types.js";
 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 { BaseRelation, AbstractProperty, PrimaryKey, RelationOutputStructure, ValidValue } from "../../field";
 import type { CollectionObject } from "../../builder.ts";
 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 object ? never : T;
 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;
+    [K in keyof Fields]: Fields[K] extends AbstractProperty<infer Output, any> ? 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 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;
+    [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>;
@@ -17,7 +21,7 @@ export interface QueryInput<All extends string, Fields extends Dict<ValidValue>,
 }
 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;
+    [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 AbstractProperty<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,5 +1,5 @@
 import type { CollectionObject } from "../../builder.ts";
-import type { Dict, ValidKey } from "../../types/common.js";
+import type { Dict, ValidKey } from "../../util-types.js";
 import type { ExtractFields, Model, ModelStructure, PrimaryKeyType } from "../../model";
 import type { AddMutation, UpdateMutation } from "./mutation.ts";
 import type { FindInput, FindOutput, WhereObject } from "./find.ts";

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

@@ -1,24 +1,24 @@
-import type { MakeArrayable, MakeOptional, RemoveNeverValues, PartialOnUndefined } from "../../types/common.js";
-import type { BaseRelation, Field, OptionalRelation, PrimaryKey, RelationArray } from "../../field";
+import type { MakeArrayable, MakeOptional, RemoveNeverValues, PartialOnUndefined } from "../../util-types.js";
+import type { BaseRelation, AbstractProperty, OptionalRelation, PrimaryKey, ArrayRelation } from "../../field";
 import type { CollectionObject } from "../../builder.ts";
 import { WhereObject } from "./find.js";
 import { Model, FindRelationKey, RelationValue } from "../../model";
 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, {
+    [K in keyof Fields]: Fields[K] extends AbstractProperty<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 ArrayRelation<any, any> ? true : MutType extends "update" ? true : false, MakeArrayable<Fields[K] extends ArrayRelation<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> ? {
+        $update: Fields[K] extends ArrayRelation<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;
+        $delete: Fields[K] extends ArrayRelation<any, any> ? RelationValue<To, C> : true;
     } | {
-        $disconnect: Fields[K] extends RelationArray<any, any> ? RelationValue<To, C> : true;
-    } : never)> | (Fields[K] extends RelationArray<any, any> ? {
+        $disconnect: Fields[K] extends ArrayRelation<any, any> ? RelationValue<To, C> : true;
+    } : never)> | (Fields[K] extends ArrayRelation<any, any> ? {
         $connectMany: RelationValue<To, C>[];
     } | {
         $createMany: Omit<Mutation<To, All, C[To], C, "add">, FindRelationKey<This, Name, C[To]>>[];

package/dist/dev-types.d.ts

@@ -0,0 +1,3 @@
+import { ParseFn, AbstractProperty, PropertyOptions } from "./field/property.js";
+import type * as util from "./util-types.js";
+export { ParseFn, AbstractProperty, util, PropertyOptions };

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

@@ -1,7 +1,7 @@
-import { ValidKey } from "../types/common.js";
-import { Field } from "./field.js";
+import { Dict, ValidKey, ValidKeyType } from "../util-types.js";
 import PrimaryKey from "./primary-key.js";
-import { BaseRelation, OptionalRelation, RelationArray } from "./relation.js";
+import { AbstractProperty, ParseFn, Property } from "./property.js";
+import { BaseRelation, OptionalRelation, ArrayRelation } from "./relation.js";
 export type ReferenceActions = "Cascade" | "None" | "Restrict";
 export type OptionalActions = "SetNull" | ReferenceActions;
 export interface RelationOptions<Name extends string, OnDelete> {
@@ -24,6 +24,13 @@ 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 RelationArray<any, any> ? Output[] : R extends OptionalRelation<any, any> ? Output | undefined : Output;
-export type NonRelationOutput<T> = T extends Field<infer Out, any> ? Out : T extends PrimaryKey<any, infer Type> ? Type : never;
-export type ValidValue<N extends string = string> = BaseRelation<N, string> | Field<any, any> | PrimaryKey<boolean, ValidKey>;
+export type RelationOutputStructure<R extends BaseRelation<any, any>, Output> = R extends ArrayRelation<any, any> ? Output[] : R extends OptionalRelation<any, any> ? Output | undefined : 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;
+export declare const VALIDATORS: {
+    [K in ValidKeyType]: ParseFn<FunctionMatch<K>>;
+};

package/dist/field/field.d.ts

@@ -18,7 +18,7 @@ export declare class Field<OutputType, HasDefault extends boolean = false> {
     constructor(schema: z.ZodType<OutputType>, options?: Partial<FieldOptions>);
     array(): Field<OutputType[], false>;
     optional(): Field<OutputType | undefined, false>;
-    default(defaultValue: NonNullable<OutputType>): Field<NonNullable<OutputType>, true>;
+    default(defaultValue: Exclude<OutputType, undefined>): Field<Exclude<OutputType, undefined>, true>;
     refine(refineFn: (val: OutputType) => boolean): void;
     parse(value: unknown): z.ZodSafeParseResult<OutputType>;
     hasDefaultValue(): HasDefault;

package/dist/field/index.d.ts

@@ -1,5 +1,5 @@
-export * from "./field.js";
 import PrimaryKey from "./primary-key.js";
 export { PrimaryKey };
 export * from "./relation.js";
 export * from "./field-types.js";
+export * from "./property.js";

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

@@ -1,4 +1,4 @@
-import { ValidKey, ValidKeyType } from "../types/common.js";
+import { ValidKey, ValidKeyType } from "../util-types.js";
 import { GenFunction } from "./field-types.js";
 export default class PrimaryKey<AutoGenerate extends boolean, Type extends ValidKey> {
     private genFn?;
@@ -11,7 +11,7 @@ export default class PrimaryKey<AutoGenerate extends boolean, Type extends Valid
     generator(genFn: GenFunction<Type>): PrimaryKey<true, Type>;
     uuid(): PrimaryKey<true, string>;
     genKey(): Type;
-    getSchema(): import("zod").ZodString | import("zod").ZodNumber | import("zod").ZodDate;
+    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

package/dist/field/property.d.ts

@@ -1,21 +1,12 @@
-import { Literable, ValidKeyType } from "../types/common.js";
-import { FunctionMatch, ReferenceActions, RelationOptions } from "./field-types.js";
+import { Literable, NoUndefined, ValidKeyType } from "../util-types.js";
+import { Type } from "../utils.js";
+import { FunctionMatch, PropertyUnion, ReferenceActions, RelationOptions } from "./field-types.js";
 import PrimaryKey from "./primary-key.js";
 import { Relation } from "./relation.js";
 export interface PropertyOptions {
     unique: boolean;
 }
 type InputOptions = Partial<PropertyOptions>;
-declare enum PropertType {
-    String = 0,
-    Number = 1,
-    BigInt = 2,
-    Boolean = 3,
-    Symbol = 4,
-    Array = 5,
-    Object = 6,
-    Unknown = 7
-}
 export type ParseResult<T> = {
     success: true;
     data: T;
@@ -31,16 +22,17 @@ export type ParseResult<T> = {
 export type ParseFn<T> = (value: unknown) => ParseResult<T>;
 export declare abstract class AbstractProperty<Value, HasDefault extends boolean> {
     readonly validate: (value: unknown) => ParseResult<Value>;
-    protected type: PropertType;
+    protected type: Type;
     protected hasDefault: HasDefault;
     protected options: PropertyOptions;
-    constructor(validate: (value: unknown) => ParseResult<Value>, type: PropertType, options?: InputOptions);
+    constructor(validate: (value: unknown) => ParseResult<Value>, type: Type, options?: InputOptions);
     abstract array(...args: unknown[]): AbstractProperty<Value[], false>;
     abstract optional(...args: unknown[]): AbstractProperty<Value | undefined, false>;
-    abstract default(defaultValue: Value): AbstractProperty<NonNullable<Value>, true>;
+    abstract default(defaultValue: Value): AbstractProperty<NoUndefined<Value>, true>;
     static array<T>(_prop: AbstractProperty<T, boolean> | ParseFn<T>, _options?: InputOptions): AbstractProperty<T[], false>;
     static literal<const V extends Literable>(_value: V, _options?: InputOptions): AbstractProperty<V, false>;
     static custom<T>(_fn: ParseFn<T>, _options?: InputOptions): AbstractProperty<T, false>;
+    static union<const T extends readonly (ParseFn<any> | AbstractProperty<any, boolean>)[]>(_items: T, _options?: InputOptions): AbstractProperty<PropertyUnion<T>, false>;
     static string(_options?: InputOptions): AbstractProperty<string, false>;
     static number(_options?: InputOptions): AbstractProperty<number, false>;
     static boolean(_options?: InputOptions): AbstractProperty<boolean, false>;
@@ -53,18 +45,24 @@ export declare abstract class AbstractProperty<Value, HasDefault extends boolean
     hasDefaultValue(): HasDefault;
     static relation<To extends string, Name extends string = never>(to: To, options?: RelationOptions<Name, ReferenceActions>): Relation<To, Name>;
     static primaryKey<V extends ValidKeyType = "number">(type?: V): PrimaryKey<false, FunctionMatch<V>>;
+    static readonly validators: {
+        string: ParseFn<string>;
+        number: ParseFn<number>;
+        date: ParseFn<Date>;
+    };
+    protected static literalToType(value: Literable): Type;
 }
 export declare class Property<Value, HasDefault extends boolean> extends AbstractProperty<Value, HasDefault> {
     array(): Property<Value[], false>;
-    default(defaultValue: NonNullable<Value>): Property<NonNullable<Value>, true>;
+    default(defaultValue: NoUndefined<Value>): Property<NoUndefined<Value>, true>;
     optional(): Property<Value | undefined, false>;
     static literal<const V extends Literable>(value: V, options?: InputOptions): Property<V, false>;
     static string(options?: InputOptions): Property<string, false>;
     static number(options?: InputOptions): Property<number, false>;
     static boolean(options?: InputOptions): Property<boolean, false>;
+    static union<const T extends readonly (ParseFn<any> | AbstractProperty<any, boolean>)[]>(items: T, options?: InputOptions): Property<PropertyUnion<T>, false>;
     static custom<T>(fn: ParseFn<T>, options?: InputOptions): Property<T, false>;
     static array<T>(item: ParseFn<T> | Property<T, boolean>, options?: InputOptions): Property<T[], false>;
-    private static literalToType;
     private static generateArrayValidator;
 }
 export {};

package/dist/field/relation.d.ts

@@ -58,7 +58,7 @@ export declare class Relation<To extends string, Name extends string> extends Ba
      *
      * **Note: Calling this function will reset any relation actions to the default**
      */
-    array({ onDelete, }?: Omit<RelationOptions<Name, OptionalActions>, "name">): RelationArray<To, Name>;
+    array({ onDelete, }?: Omit<RelationOptions<Name, OptionalActions>, "name">): ArrayRelation<To, Name>;
     /**
      * Creates an optional relation to the specified model
      *
@@ -67,7 +67,7 @@ export declare class Relation<To extends string, Name extends string> extends Ba
     optional({ onDelete, }?: Omit<RelationOptions<Name, OptionalActions>, "name">): OptionalRelation<To, Name>;
     onDelete(action: ReferenceActions): this;
 }
-export declare class RelationArray<To extends string, Name extends string> extends BaseRelation<To, Name> {
+export declare class ArrayRelation<To extends string, Name extends string> extends BaseRelation<To, Name> {
     private readonly _brand;
     constructor(to: To, name?: Name, action?: OptionalActions);
 }

package/dist/index.d.ts

@@ -1,8 +1,9 @@
 import { Builder } from "./builder.js";
 import { StoreError, type ErrorType } from "./error.js";
+import "./dev-types.js";
 export { Builder, StoreError, ErrorType };
-import { Field } from "./field";
-export { Field };
+import { Property } from "./field";
+export { Property };
 import { CompiledQuery } from "./client/compiled-query.js";
 export { CompiledQuery };
 import type { ModelType } from "./model";