@idb-orm/core 1.0.3

package/dist/error.d.ts

@@ -0,0 +1,194 @@
+export type ErrorType = "ID_EXISTS" | "INVALID_ITEM" | "ADD_FAILED" | "UPDATE_FAILED" | "DELETE_FAILED" | "OVERWRITE_RELATION" | "NOT_FOUND" | "GET_FAILED"
+/**
+ * The given transaction is invalid for the store it is trying to access
+ */
+ | "INVALID_TX"
+/**
+ * The database is not found
+ */
+ | "NO_DB" | "CUSTOM" | "INVALID_CONFIG" | "ASSERTION_FAILED" | "OPEN_CURSOR" | "UNKNOWN";
+export declare class StoreError extends Error {
+    readonly code: ErrorType;
+    readonly message: string;
+    constructor(code: ErrorType, message: string);
+}
+export declare const InvalidConfigError: {
+    new (message?: string): {
+        readonly code: ErrorType;
+        readonly message: string;
+        name: string;
+        stack?: string;
+        cause?: unknown;
+    };
+    readonly code: "INVALID_CONFIG";
+    of(message: string): void;
+    isError(error: unknown): error is Error;
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+    stackTraceLimit: number;
+};
+export declare const InvalidTransactionError: {
+    new (message?: string): {
+        readonly code: ErrorType;
+        readonly message: string;
+        name: string;
+        stack?: string;
+        cause?: unknown;
+    };
+    readonly code: "INVALID_TX";
+    of(message: string): void;
+    isError(error: unknown): error is Error;
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+    stackTraceLimit: number;
+};
+export declare const InvalidItemError: {
+    new (message?: string): {
+        readonly code: ErrorType;
+        readonly message: string;
+        name: string;
+        stack?: string;
+        cause?: unknown;
+    };
+    readonly code: "INVALID_ITEM";
+    of(message: string): void;
+    isError(error: unknown): error is Error;
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+    stackTraceLimit: number;
+};
+export declare const AssertionError: {
+    new (message?: string): {
+        readonly code: ErrorType;
+        readonly message: string;
+        name: string;
+        stack?: string;
+        cause?: unknown;
+    };
+    readonly code: "ASSERTION_FAILED";
+    of(message: string): void;
+    isError(error: unknown): error is Error;
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+    stackTraceLimit: number;
+};
+export declare const UnknownError: {
+    new (message?: string): {
+        readonly code: ErrorType;
+        readonly message: string;
+        name: string;
+        stack?: string;
+        cause?: unknown;
+    };
+    readonly code: "UNKNOWN";
+    of(message: string): void;
+    isError(error: unknown): error is Error;
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+    stackTraceLimit: number;
+};
+export declare const DeleteError: {
+    new (message?: string): {
+        readonly code: ErrorType;
+        readonly message: string;
+        name: string;
+        stack?: string;
+        cause?: unknown;
+    };
+    readonly code: "DELETE_FAILED";
+    of(message: string): void;
+    isError(error: unknown): error is Error;
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+    stackTraceLimit: number;
+};
+export declare const ObjectStoreNotFoundError: {
+    new (message?: string): {
+        readonly code: ErrorType;
+        readonly message: string;
+        name: string;
+        stack?: string;
+        cause?: unknown;
+    };
+    readonly code: "NOT_FOUND";
+    of(message: string): void;
+    isError(error: unknown): error is Error;
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+    stackTraceLimit: number;
+};
+export declare const DocumentNotFoundError: {
+    new (message?: string): {
+        readonly code: ErrorType;
+        readonly message: string;
+        name: string;
+        stack?: string;
+        cause?: unknown;
+    };
+    readonly code: "NOT_FOUND";
+    of(message: string): void;
+    isError(error: unknown): error is Error;
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+    stackTraceLimit: number;
+};
+export declare const UpdateError: {
+    new (message?: string): {
+        readonly code: ErrorType;
+        readonly message: string;
+        name: string;
+        stack?: string;
+        cause?: unknown;
+    };
+    readonly code: "UPDATE_FAILED";
+    of(message: string): void;
+    isError(error: unknown): error is Error;
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+    stackTraceLimit: number;
+};
+export declare const AddError: {
+    new (message?: string): {
+        readonly code: ErrorType;
+        readonly message: string;
+        name: string;
+        stack?: string;
+        cause?: unknown;
+    };
+    readonly code: "ADD_FAILED";
+    of(message: string): void;
+    isError(error: unknown): error is Error;
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+    stackTraceLimit: number;
+};
+export declare const OpenCursorError: {
+    new (message?: string): {
+        readonly code: ErrorType;
+        readonly message: string;
+        name: string;
+        stack?: string;
+        cause?: unknown;
+    };
+    readonly code: "OPEN_CURSOR";
+    of(message: string): void;
+    isError(error: unknown): error is Error;
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+    stackTraceLimit: number;
+};
+export declare const RetrievalError: {
+    new (message?: string): {
+        readonly code: ErrorType;
+        readonly message: string;
+        name: string;
+        stack?: string;
+        cause?: unknown;
+    };
+    readonly code: "GET_FAILED";
+    of(message: string): void;
+    isError(error: unknown): error is Error;
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+    stackTraceLimit: number;
+};

package/dist/field/constants.d.ts

@@ -0,0 +1,9 @@
+import z from "zod";
+export declare const DEFAULT_SCHEMA_MAP: {
+    string: z.ZodString;
+    boolean: z.ZodBoolean;
+    number: z.ZodNumber;
+    array: z.ZodArray<z.ZodAny>;
+    object: z.ZodObject<{}, z.core.$loose>;
+    date: z.ZodDate;
+};

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

@@ -0,0 +1,29 @@
+import { ValidKey } from "../types/common.js";
+import { Field } from "./field.js";
+import PrimaryKey from "./primary-key.js";
+import { BaseRelation, OptionalRelation, RelationArray } from "./relation.js";
+export type ReferenceActions = "Cascade" | "None" | "Restrict";
+export type OptionalActions = "SetNull" | ReferenceActions;
+export interface RelationOptions<Name extends string, OnDelete> {
+    name?: Name;
+    onDelete?: OnDelete;
+}
+export interface RelationActions {
+    onDelete: OptionalActions;
+}
+export declare const enum FieldTypes {
+    Field = 0,
+    Relation = 1,
+    PrimaryKey = 2,
+    Invalid = 3
+}
+export type GenFunction<T extends ValidKey> = () => T;
+export type FunctionMatch<E> = E extends "string" ? string : E extends "number" ? number : E extends "date" ? Date : never;
+export type GetPrimaryKeyType<T> = T extends PrimaryKey<any, infer Type> ? Type : never;
+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>;

package/dist/field/field.d.ts

@@ -0,0 +1,40 @@
+import z from "zod";
+import type { ValidKeyType } from "../types/common.js";
+import type { FieldOptions, FunctionMatch, ReferenceActions, RelationOptions } from "./field-types.js";
+import PrimaryKey from "./primary-key.js";
+import { Relation } from "./relation.js";
+export declare class Field<OutputType, HasDefault extends boolean = false> {
+    schema: z.ZodType<OutputType>;
+    private hasDefault;
+    static readonly schemas: {
+        string: z.ZodString;
+        boolean: z.ZodBoolean;
+        number: z.ZodNumber;
+        array: z.ZodArray<z.ZodAny>;
+        object: z.ZodObject<{}, z.core.$loose>;
+        date: z.ZodDate;
+    };
+    private options;
+    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>;
+    refine(refineFn: (val: OutputType) => boolean): void;
+    parse(value: unknown): z.ZodSafeParseResult<OutputType>;
+    hasDefaultValue(): HasDefault;
+    /**
+     * 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(): OutputType extends string | number | boolean | symbol ? this : null;
+    static array<T>(item: z.ZodType<T> | Field<T>, options?: FieldOptions): Field<T[], false>;
+    static boolean(schema?: z.ZodType<boolean>, options?: FieldOptions): Field<boolean, false>;
+    static custom<T>(schema: z.ZodType<T>, options?: FieldOptions): Field<T, false>;
+    static object<T extends Record<string, z.ZodType>>(item: T, options?: FieldOptions): Field<z.core.$InferObjectOutput<{ -readonly [P in keyof T]: T[P]; }, {}>, false>;
+    static primaryKey<V extends ValidKeyType = "number">(type?: V): PrimaryKey<false, FunctionMatch<V>>;
+    static literal<V extends string | number | boolean>(value: V): Field<V, false>;
+    static number(schema?: z.ZodType<number>, options?: FieldOptions): Field<number, false>;
+    static string(schema?: z.ZodType<string>, options?: FieldOptions): Field<string, false>;
+    static relation<To extends string, Name extends string = never>(to: To, options?: RelationOptions<Name, ReferenceActions>): Relation<To, Name>;
+}

package/dist/field/index.d.ts

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

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

@@ -0,0 +1,20 @@
+import { ValidKey, ValidKeyType } from "../types/common.js";
+import { GenFunction } from "./field-types.js";
+export default class PrimaryKey<AutoGenerate extends boolean, Type extends ValidKey> {
+    private genFn?;
+    private autoGenerate;
+    readonly type: ValidKeyType;
+    constructor();
+    constructor(type: ValidKeyType);
+    constructor(type: ValidKeyType, generator: GenFunction<Type>);
+    autoIncrement(): PrimaryKey<true, number>;
+    generator(genFn: GenFunction<Type>): PrimaryKey<true, Type>;
+    uuid(): PrimaryKey<true, string>;
+    genKey(): Type;
+    getSchema(): import("zod").ZodString | import("zod").ZodNumber | import("zod").ZodDate;
+    /**
+     * If the internal objectStore "autoIncrement" utility is being used
+     * @returns
+     */
+    isAutoIncremented(): boolean;
+}

package/dist/field/relation.d.ts

@@ -0,0 +1,77 @@
+import type { OptionalActions, ReferenceActions, RelationActions, RelationOptions } from "./field-types.js";
+export declare class BaseRelation<To extends string, Name extends string = never> {
+    /**
+     * The name of the model this relation is pointing to
+     */
+    readonly to: To;
+    /**
+     * An optional label to give to the relation. This helps distinguish it from others
+     */
+    readonly name: Name;
+    /**
+     * If the relation is optional or not
+     */
+    readonly isOptional: boolean;
+    /**
+     * If the relation is an array or not
+     */
+    readonly isArray: boolean;
+    /**
+     * Actions to be performed under certain conditions
+     */
+    protected actions: RelationActions;
+    /**
+     * The corresponding relation key on the model this relation points to
+     */
+    private relatedKey;
+    constructor(
+    /**
+     * The name of the model this relation is pointing to
+     */
+    to: To, 
+    /**
+     * An optional label to give to the relation. This helps distinguish it from others
+     */
+    name?: Name, 
+    /**
+     * If the relation is optional or not
+     */
+    isOptional?: boolean, 
+    /**
+     * If the relation is an array or not
+     */
+    isArray?: boolean, onDelete?: OptionalActions);
+    getActions(): {
+        onDelete: OptionalActions;
+    };
+    setRelatedKey(key: string): void;
+    /**
+     * Gets the key on the corresponding model this relation points to
+     */
+    getRelatedKey(): string;
+}
+export declare class Relation<To extends string, Name extends string> extends BaseRelation<To, Name> {
+    private readonly _brand;
+    constructor(to: To, options?: RelationOptions<Name, ReferenceActions>);
+    /**
+     * Creates an array relation to the specified model
+     *
+     * **Note: Calling this function will reset any relation actions to the default**
+     */
+    array({ onDelete, }?: Omit<RelationOptions<Name, OptionalActions>, "name">): RelationArray<To, Name>;
+    /**
+     * Creates an optional relation to the specified model
+     *
+     * **Note: Calling this function will reset any relation actions to the default**
+     */
+    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> {
+    private readonly _brand;
+    constructor(to: To, name?: Name, action?: OptionalActions);
+}
+export declare class OptionalRelation<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

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