@idb-orm/core 1.0.5 → 1.0.7

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,4 @@
+import { ParseFn, AbstractProperty, PropertyOptions } from "./field/property.js";
+import * as util from "./util-types.js";
+import { Type } from "./utils.js";
+export { ParseFn, AbstractProperty, util, PropertyOptions, Type };

package/dist/dev.d.ts

@@ -0,0 +1,5 @@
+import { ParseFn, AbstractProperty, PropertyOptions, PropertyInputOptions } from "./field/property.js";
+import { PropertyUnion } from "./field/field-types.js";
+import * as util from "./util-types.js";
+import { Type } from "./utils.js";
+export { ParseFn, AbstractProperty, util, PropertyOptions, Type, PropertyInputOptions, PropertyUnion, };

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/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 PropertyInputOptions = Partial<PropertyOptions>;
 export type ParseResult<T> = {
     success: true;
     data: T;
@@ -26,24 +17,26 @@ export type ParseResult<T> = {
     error: string;
 };
 /**
- * A function to parse and validate an unknown value. It should also handle applying defaults
+ * A function to parse and validateFn an unknown value. It should also handle applying defaults
  */
 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 validateFn: (value: unknown) => ParseResult<Value>;
+    protected type: Type;
     protected hasDefault: HasDefault;
     protected options: PropertyOptions;
-    constructor(validate: (value: unknown) => ParseResult<Value>, type: PropertType, options?: InputOptions);
+    constructor(validateFn: (value: unknown) => ParseResult<Value>, type: Type, options?: PropertyInputOptions);
+    get validate(): (value: unknown) => ParseResult<Value>;
     abstract array(...args: unknown[]): AbstractProperty<Value[], false>;
     abstract optional(...args: unknown[]): AbstractProperty<Value | undefined, false>;
-    abstract default(defaultValue: Value): AbstractProperty<Exclude<Value, undefined>, 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 string(_options?: InputOptions): AbstractProperty<string, false>;
-    static number(_options?: InputOptions): AbstractProperty<number, false>;
-    static boolean(_options?: InputOptions): AbstractProperty<boolean, false>;
+    abstract default(defaultValue: NoUndefined<Value>): AbstractProperty<NoUndefined<Value>, true>;
+    static array<T>(..._args: unknown[]): AbstractProperty<T[], false>;
+    static literal<const V extends Literable>(_item: V, ..._: unknown[]): AbstractProperty<V, false>;
+    static custom<T>(..._: unknown[]): AbstractProperty<T, false>;
+    static union<const _T extends readonly (ParseFn<any> | AbstractProperty<any, boolean>)[]>(..._: unknown[]): AbstractProperty<unknown, false>;
+    static string(..._: unknown[]): AbstractProperty<string, false>;
+    static number(..._: unknown[]): AbstractProperty<number, false>;
+    static boolean(..._: unknown[]): AbstractProperty<boolean, false>;
     /**
      * Indicates that a field must be unique across all documents
      *
@@ -53,18 +46,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;
+    protected static nameToType(typeName: string): Type;
 }
 export declare class Property<Value, HasDefault extends boolean> extends AbstractProperty<Value, HasDefault> {
     array(): Property<Value[], false>;
-    default(defaultValue: Exclude<Value, undefined>): Property<Exclude<Value, undefined>, 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 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;
+    static literal<const V extends Literable>(value: V, options?: PropertyInputOptions): Property<V, false>;
+    static string(options?: PropertyInputOptions): Property<string, false>;
+    static number(options?: PropertyInputOptions): Property<number, false>;
+    static boolean(options?: PropertyInputOptions): Property<boolean, false>;
+    static union<const T extends readonly (ParseFn<any> | AbstractProperty<any, boolean>)[]>(items: T, options?: PropertyInputOptions): Property<PropertyUnion<T>, false>;
+    static custom<T>(fn: ParseFn<T>, options?: PropertyInputOptions): Property<T, false>;
+    static array<T>(item: ParseFn<T> | Property<T, boolean>, options?: PropertyInputOptions): Property<T[], false>;
     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.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";