@idb-orm/core 1.0.3 → 1.0.4

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<NonNullable<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 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: NonNullable<Value>): Property<NonNullable<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;
+    private static generateArrayValidator;
+}
+export {};