@idb-orm/core 1.0.3 → 1.0.5

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

@@ -1,225 +1,46 @@
-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 type { MakeArrayable, MakeOptional, RemoveNeverValues, PartialOnUndefined } from "../../types/common.js";
+import type { BaseRelation, Field, OptionalRelation, PrimaryKey, RelationArray } from "../../field";
+import type { CollectionObject } from "../../builder.ts";
 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>
-> {
+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, {
+        $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;
+type WhereSelection<Struct extends object> = Struct extends Model<any, infer Fields, any> ? WhereObject<Fields> : never;
 export {};

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/property.d.ts

@@ -0,0 +1,70 @@
+import { Literable, ValidKeyType } from "../types/common.js";
+import { FunctionMatch, 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;
+    error?: undefined;
+} | {
+    success: false;
+    data?: undefined;
+    error: string;
+};
+/**
+ * A function to parse and validate 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 hasDefault: HasDefault;
+    protected options: PropertyOptions;
+    constructor(validate: (value: unknown) => ParseResult<Value>, type: PropertType, options?: InputOptions);
+    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>;
+    /**
+     * Indicates that a field must be unique across all documents
+     *
+     * **NOTE**: The field type must be a primitive. If this is applied to a non-primitive, it returns `null`
+     */
+    unique(): Value extends string | number | boolean | symbol ? this : null;
+    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>>;
+}
+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>;
+    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;
+    private static generateArrayValidator;
+}
+export {};