@idb-orm/core 1.0.3

package/dist/model/index.d.ts

@@ -0,0 +1,3 @@
+import Model from "./model.js";
+export * from "./model-types.js";
+export { Model };

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

@@ -0,0 +1,125 @@
+import { CompiledDb } from "../builder.js";
+import {
+    BaseRelation,
+    Field,
+    OptionalRelation,
+    PrimaryKey,
+    Relation,
+    RelationArray,
+    RelationOutput,
+    ValidValue,
+} from "../field/index.js";
+import { Dict, Keyof, ZodWrap } from "../types/common.js";
+import Model from "./model.js";
+export type FindPrimaryKey<F extends Record<string, ValidValue>> = Extract<
+    {
+        [K in keyof F]: F[K] extends PrimaryKey<any, any> ? K : never;
+    }[keyof F],
+    string
+>;
+export type PrimaryKeyType<M extends Model<any, any, any>> = M extends Model<
+    any,
+    infer F,
+    any
+>
+    ? {
+          [K in keyof F]: F[K] extends PrimaryKey<any, infer Type>
+              ? Type
+              : never;
+      }[keyof F]
+    : never;
+export interface ModelCache {
+    delete?: Set<string>;
+}
+/**
+ * Gets the type of a relation given its name
+ */
+export type RelationValue<Name extends string, C> = Name extends keyof C
+    ? C[Name] extends Model<any, infer Fields, infer PrimaryKey>
+        ? RelationOutput<Fields[PrimaryKey]>
+        : never
+    : never;
+/**
+ * Gets the primitive type of the relation field
+ */
+export type GetRelationField<F, C> = F extends Relation<infer To, any>
+    ? RelationValue<To, C>
+    : F extends OptionalRelation<infer To, any>
+    ? RelationValue<To, C> | undefined
+    : F extends RelationArray<infer To, any>
+    ? RelationValue<To, C>[]
+    : never;
+export type ModelStructure<F extends Dict<ValidValue>, C> = {
+    [K in keyof F]: F[K] extends Field<infer Output, any>
+        ? Output
+        : F[K] extends PrimaryKey<any, infer Type>
+        ? Type
+        : GetRelationField<F[K], C>;
+};
+export type ModelType<
+    M extends Model<any, any, any>,
+    C extends CompiledDb<any, any, any>
+> = M extends Model<any, infer Fields, any>
+    ? C extends CompiledDb<any, any, infer Collection>
+        ? ModelStructure<Fields, Collection>
+        : never
+    : never;
+export type ExtractFields<M extends Model<any, any, any>> = M extends Model<
+    any,
+    infer Fields,
+    any
+>
+    ? Fields
+    : never;
+export type AllRelationKeys<M extends Model<any, any, any>> = M extends Model<
+    any,
+    infer Fields,
+    any
+>
+    ? {
+          [K in Keyof<Fields>]: Fields[K] extends BaseRelation<any, any>
+              ? K
+              : never;
+      }[Keyof<Fields>]
+    : never;
+export type RelationlessModelStructure<M extends Model<any, any, any>> =
+    M extends Model<any, infer Fields, any>
+        ? Omit<
+              {
+                  [K in Keyof<Fields>]: Fields[K] extends BaseRelation<any, any>
+                      ? unknown
+                      : Fields[K] extends Field<infer Type, any>
+                      ? Type
+                      : Fields[K] extends PrimaryKey<any, infer Type>
+                      ? Type
+                      : never;
+              },
+              AllRelationKeys<M>
+          >
+        : never;
+export type CollectionZodSchema<C> = C extends Record<
+    infer Keys,
+    Model<any, any, any>
+>
+    ? {
+          [K in Keys]: C[K] extends Model<any, infer Fields, any>
+              ? ZodWrap<ModelStructure<Fields, C>>
+              : never;
+      }
+    : never;
+export type FindRelationKey<
+    From extends string,
+    RelationName extends string,
+    M extends Model<any, any, any>
+> = M extends Model<any, infer Fields, any>
+    ? {
+          [K in Keyof<Fields>]: Fields[K] extends BaseRelation<
+              From,
+              infer CurName
+          >
+              ? CurName extends RelationName
+                  ? K
+                  : never
+              : never;
+      }[Keyof<Fields>]
+    : never;

package/dist/model/model.d.ts

@@ -0,0 +1,42 @@
+import z from "zod";
+import { CollectionObject } from "../builder.js";
+import { DbClient } from "../client/index.js";
+import {
+    BaseRelation,
+    Field,
+    FieldTypes,
+    PrimaryKey,
+    ValidValue,
+} from "../field/index.js";
+import { Keyof, ValidKey } from "../types/common.js";
+import { FindPrimaryKey } from "./model-types.js";
+export default class Model<
+    Name extends string,
+    F extends Record<string, ValidValue>,
+    Primary extends FindPrimaryKey<F> = FindPrimaryKey<F>
+> {
+    readonly name: Name;
+    private readonly fields;
+    private readonly fieldKeys;
+    private readonly relationLinks;
+    private cache;
+    readonly primaryKey: Primary;
+    constructor(name: Name, fields: F);
+    get<K extends Keyof<F>>(key: K): F[K];
+    getModelField(key: string): Field<any, any> | undefined;
+    getPrimaryKey(): PrimaryKey<boolean, ValidKey>;
+    getRelation<Models extends string>(
+        key: string
+    ): BaseRelation<Models, string> | undefined;
+    keyType(key: Keyof<F>): FieldTypes;
+    links<Names extends string = string>(): SetIterator<Names>;
+    keys(): Keyof<F>[];
+    parseField<K extends Keyof<F>>(
+        field: K,
+        value: unknown
+    ): z.ZodSafeParseResult<any>;
+    getDeletedStores<
+        ModelNames extends string,
+        Models extends CollectionObject<ModelNames>
+    >(client: DbClient<string, ModelNames, Models>): Set<ModelNames>;
+}

package/dist/object-store.d.ts

@@ -0,0 +1,27 @@
+/**
+ * A paper thin wrapper around IDBObjectStore
+ */
+import { Promisable } from "type-fest";
+import { StoreError } from "./error.js";
+import { Transaction } from "./transaction.js";
+import { Dict, ValidKey } from "./types/common.js";
+export declare class ObjectStore {
+    private readonly tx;
+    readonly store: IDBObjectStore;
+    constructor(tx: Transaction<IDBTransactionMode, string>, store: IDBObjectStore);
+    add(item: Dict): Promise<ValidKey>;
+    /**
+     * Attempts to retrieve the value from the object store.
+     *
+     * Returns `undefined` if no value was found
+     */
+    get(key: ValidKey): Promise<Dict>;
+    put(item: Dict): Promise<ValidKey>;
+    delete(key: ValidKey): Promise<undefined>;
+    openCursor(callback: (cursor: IDBCursorWithValue, tx: Transaction<IDBTransactionMode, string>) => Promisable<boolean>, options?: {
+        query?: IDBValidKey | IDBKeyRange;
+        direction?: IDBCursorDirection;
+        onError?: () => StoreError;
+    }): Promise<void>;
+    private handleRequest;
+}

package/dist/transaction.d.ts

@@ -0,0 +1,50 @@
+import type { Arrayable } from "type-fest";
+import { StoreError } from "./error.js";
+import { ObjectStore } from "./object-store.js";
+export type TransactionStatus = "running" | "aborted" | "complete" | "error";
+export type TransactionEventHandler = (
+    tx: Transaction<IDBTransactionMode>,
+    ev: Event
+) => void;
+export interface TransactionOptions
+    extends Partial<{
+        onAbort: TransactionEventHandler;
+        onError: TransactionEventHandler;
+        onComplete: TransactionEventHandler;
+    }> {}
+export declare class Transaction<
+    Mode extends IDBTransactionMode,
+    Stores extends string = string
+> {
+    private internal;
+    status: TransactionStatus;
+    error: StoreError | null;
+    readonly storeNames: Stores[];
+    /**
+     * A record of store names to `IDBObjectStore` objects
+     */
+    private readonly objectStores;
+    constructor(
+        db: IDBDatabase,
+        stores: Arrayable<Stores>,
+        mode: Mode,
+        options?: TransactionOptions
+    );
+    abort(error: StoreError): StoreError;
+    commit(): void;
+    /**
+     * Gets the internal `IDBTransaction` object
+     *
+     * It's recommended you don't use this function and use the built-in functions of the wrapper
+     * @returns Internal transaction object
+     */
+    getInternal(): IDBTransaction;
+    getStore(store: Stores): ObjectStore;
+    get mode(): Mode;
+    is(status: TransactionStatus): boolean;
+    contains(stores: Arrayable<string>): boolean;
+    assertIsArray(value: any, message?: string): asserts value is any[];
+    private getObjectstore;
+    private registerHandler;
+    wrap<Output>(fn: (tx: this) => Promise<Output>): Promise<Output>;
+}

package/dist/types/common.d.ts

@@ -0,0 +1,37 @@
+import type { Arrayable, IsNever } from "type-fest";
+import type z from "zod";
+/**
+ * Extracts the string keys of an object
+ */
+export type Keyof<T extends Record<any, any>> = Extract<keyof T, string>;
+export type MakeOptional<B extends boolean, T> = B extends true ? T | undefined : T;
+export type MakeArray<B extends boolean, T> = B extends true ? T[] : T;
+export type MakeArrayable<B extends boolean, T> = B extends true ? Arrayable<T> : T;
+export type ValidKey = string | number | Date;
+export type ValidKeyType = "string" | "number" | "date";
+export type If<Type extends boolean, IfBranch, ElseBranch> = IsNever<Type> extends true ? ElseBranch : Type extends true ? IfBranch : ElseBranch;
+export type RemoveNeverValues<T extends object> = {
+    [K in keyof T as T[K] extends never ? never : K]: T[K];
+};
+export type Dict<T = unknown> = Record<string, T>;
+export type ConnectionObject<M extends boolean = false, T = object, K = ValidKey> = {
+    $create: T;
+    $connect: K;
+} & If<M, {
+    $createMany: T[];
+    $connectMany: K[];
+}, Dict>;
+export type ZodWrap<T extends Dict> = {
+    [K in keyof T]: z.ZodType<T[K]>;
+};
+type UndefinedKeys<T extends Dict> = {
+    [K in Keyof<T>]: undefined extends T[K] ? K : never;
+}[Keyof<T>];
+type Optional<T extends Dict> = Partial<Pick<T, UndefinedKeys<T>>>;
+type Required<T extends Dict> = Omit<T, UndefinedKeys<T>>;
+export type PartialOnUndefined<T extends Dict> = Required<T> & Optional<T>;
+/**
+ * Types that can be resolved to specific boolean values
+ */
+export type BooleanLike = boolean | undefined | null | 0;
+export {};

package/dist/utils.d.ts

@@ -0,0 +1,17 @@
+import type { Keyof } from "./types/common";
+import type { Arrayable } from "type-fest";
+import type { Transaction } from "./transaction.js";
+export declare function handleRequest<T>(req: IDBRequest<T>, tx?: Transaction<any, any>): Promise<T>;
+export declare function getKeys<T extends object>(obj: T): Keyof<T>[];
+export declare function addToSet<T>(set: Set<T>, items: T[]): Set<T>;
+export declare function toArray<T>(value: Arrayable<T>): T[];
+/**
+ * Identity Function, it returns the first argument it is given, all others are ignored
+ * @param value Value
+ * @returns Same Value
+ */
+export declare function identity<T>(value: T): T;
+/**
+ * Performs a union over `set1` and `set2`, modifying `set1` to be union of the two sets
+ */
+export declare function unionSets<T>(set: Set<T>, other: Set<T>): Set<T>;

package/eslint.config.js

@@ -0,0 +1,55 @@
+import eslint from "@eslint/js";
+import { defineConfig } from "eslint/config";
+import tseslint from "typescript-eslint";
+import globals from "globals";
+import path from "path";
+
+export default defineConfig(
+    eslint.configs.recommended,
+    tseslint.configs.recommendedTypeChecked,
+    {
+        rules: {
+            "@typescript-eslint/no-explicit-any": "off",
+            "@typescript-eslint/no-unsafe-function-type": "off",
+            "@typescript-eslint/no-unsafe-assignment": "off",
+            "@typescript-eslint/no-unsafe-member-access": "off",
+            "@typescript-eslint/restrict-template-expressions": "off",
+            "@typescript-eslint/no-empty-object-type": "off",
+            "@typescript-eslint/switch-exhaustiveness-check": [
+                "error",
+                {
+                    considerDefaultExhaustiveForUnions: true,
+                },
+            ],
+            "@typescript-eslint/no-unused-vars": [
+                "error",
+                {
+                    args: "all",
+                    argsIgnorePattern: "^_",
+                    caughtErrors: "all",
+                    caughtErrorsIgnorePattern: "^_",
+                    destructuredArrayIgnorePattern: "^_",
+                    varsIgnorePattern: "^_",
+                    ignoreRestSiblings: true,
+                },
+            ],
+        },
+        languageOptions: {
+            parserOptions: {
+                projectService: true,
+                tsconfigRootDir: path.resolve("./packages/core"),
+            },
+            globals: globals.browser,
+        },
+    },
+    {
+        ignores: [
+            "eslint.config.js",
+            "rollup.config.ts",
+            "**/dist/*",
+            "**/test-client/*",
+            "**/*.config.*",
+            "**/tests/*",
+        ],
+    }
+);

package/package.json

@@ -0,0 +1,45 @@
+{
+    "name": "@idb-orm/core",
+    "version": "1.0.3",
+    "description": "",
+    "main": "dist/index.js",
+    "type": "module",
+    "scripts": {
+        "build": "rollup --config rollup.config.ts --configPlugin typescript",
+        "watch": "rollup --watch --config rollup.config.ts --configPlugin typescript",
+        "check": "eslint . && tsc -b --noEmit",
+        "test": "playwright test"
+    },
+    "keywords": [],
+    "workspaces": [
+        "packages/*"
+    ],
+    "author": "jtb",
+    "exports": {
+        ".": {
+            "types": "./dist/index.d.ts",
+            "import": "./dist/index.js",
+            "require": "./dist/index.js"
+        }
+    },
+    "license": "ISC",
+    "devDependencies": {
+        "@eslint/js": "^9.38.0",
+        "@playwright/test": "^1.56.1",
+        "@rollup/plugin-node-resolve": "^16.0.3",
+        "@rollup/plugin-terser": "^0.4.4",
+        "@rollup/plugin-typescript": "^12.1.4",
+        "@types/node": "^24.9.1",
+        "eslint": "^9.38.0",
+        "rollup": "^4.52.4",
+        "serve": "^14.2.5",
+        "tslib": "^2.8.1",
+        "typescript": "^5.9.3",
+        "typescript-eslint": "^8.46.2"
+    },
+    "dependencies": {
+        "@gilbarbara/deep-equal": "^0.3.1",
+        "uuid": "^13.0.0",
+        "zod": "^4.1.3"
+    }
+}

package/playwright.config.ts

@@ -0,0 +1,79 @@
+import { defineConfig, devices } from "@playwright/test";
+
+/**
+ * Read environment variables from file.
+ * https://github.com/motdotla/dotenv
+ */
+// import dotenv from 'dotenv';
+// import path from 'path';
+// dotenv.config({ path: path.resolve(__dirname, '.env') });
+
+/**
+ * See https://playwright.dev/docs/test-configuration.
+ */
+export default defineConfig({
+    testDir: "./tests",
+    /* Run tests in files in parallel */
+    fullyParallel: true,
+    /* Fail the build on CI if you accidentally left test.only in the source code. */
+    forbidOnly: !!process.env.CI,
+    /* Retry on CI only */
+    retries: process.env.CI ? 2 : 0,
+    /* Opt out of parallel tests on CI. */
+    workers: process.env.CI ? 1 : undefined,
+    /* Reporter to use. See https://playwright.dev/docs/test-reporters */
+    // reporter: "html",
+    /* Shared settings for all the projects below. See https://playwright.dev/docs/api/class-testoptions. */
+    use: {
+        /* Base URL to use in actions like `await page.goto('')`. */
+        // baseURL: 'http://localhost:3000',
+
+        /* Collect trace when retrying the failed test. See https://playwright.dev/docs/trace-viewer */
+        trace: "on-first-retry",
+        headless: true,
+    },
+
+    /* Configure projects for major browsers */
+    projects: [
+        {
+            name: "chromium",
+            use: { ...devices["Desktop Chrome"] },
+        },
+
+        {
+            name: "firefox",
+            use: { ...devices["Desktop Firefox"] },
+        },
+
+        {
+            name: "webkit",
+            use: { ...devices["Desktop Safari"] },
+        },
+
+        /* Test against mobile viewports. */
+        // {
+        //   name: 'Mobile Chrome',
+        //   use: { ...devices['Pixel 5'] },
+        // },
+        // {
+        //   name: 'Mobile Safari',
+        //   use: { ...devices['iPhone 12'] },
+        // },
+
+        /* Test against branded browsers. */
+        // {
+        //   name: 'Microsoft Edge',
+        //   use: { ...devices['Desktop Edge'], channel: 'msedge' },
+        // },
+        // {
+        //   name: 'Google Chrome',
+        //   use: { ...devices['Desktop Chrome'], channel: 'chrome' },
+        // },
+    ],
+
+    /* Run your local dev server before starting the tests */
+    webServer: {
+        command: "npx serve dist -l 4173",
+        port: 4173,
+    },
+});

package/tests/helpers.ts

@@ -0,0 +1,72 @@
+import { Page } from "@playwright/test";
+import { Keyof } from "../src/types/common.js";
+
+/**
+ * Will navigate to the served page and import zod and the package
+ *
+ * Will also ensure that the package is properly loaded
+ * @param context Playwright BrowserContext
+ */
+export async function populatePage<P extends Record<string, any>>(
+    page: Page,
+    vars: Record<keyof P, string | EvalFn<P, any>>
+) {
+    await page.goto("http://localhost:4173/");
+    const manager = new ContextSession<P>(page, vars);
+    await manager.populate();
+    return manager;
+}
+
+function getFn(fn: Function) {
+    return fn.toString().match(/^async \(\{([^\}]+)\}\) \=\> \{([\s\S]*)\}$/m);
+}
+
+export type EvalFn<
+    Types extends Record<string, any>,
+    This extends keyof Types
+> = (args: Omit<Types, This>) => Promise<any>;
+
+export class ContextSession<Types extends Record<string, any>> {
+    constructor(
+        private page: Page,
+        private variables: {
+            [K in keyof Types]: string | EvalFn<Types, K>;
+        }
+    ) {}
+
+    async populate() {
+        // Construct the script
+        await this.page.addScriptTag({
+            type: "module",
+            content: `
+              window.isReady = (async () => {
+              window.vars = {};
+              ${Object.keys(this.variables)
+                  .map((key) => {
+                      const element = this.variables[key];
+                      switch (typeof element) {
+                          case "function":
+                              return `window.vars.${key} = await (${element.toString()})(window.vars);`;
+                          default:
+                              return `window.vars.${key} = await ${element};`;
+                      }
+                  })
+                  .join("\n")}
+              })();
+              `,
+        });
+
+        await this.page.evaluate(async () => {
+            await (window as any).isReady;
+            await new Promise((res) => setTimeout(res, 100));
+        });
+    }
+
+    async evaluate<Result>(
+        fn: (args: Types) => Promise<Result>
+    ): Promise<Result> {
+        return await this.page.evaluate(
+            `(async () => await (${fn.toString()})(window.vars))();`
+        );
+    }
+}

package/tests/test.spec.ts

@@ -0,0 +1,101 @@
+import { test, expect, Page } from "@playwright/test";
+import { ContextSession, EvalFn, populatePage } from "./helpers.js";
+import { Builder, Field } from "../dist/index.js";
+import * as idbOrm from "../dist/index.js";
+import * as zod from "zod";
+
+export type Packages = {
+    pkg: typeof idbOrm;
+    zod: typeof zod;
+};
+export type SessionArguments = Packages & {
+    client: Awaited<ReturnType<typeof createDb>>;
+};
+
+const createDb = async ({ zod, pkg }: Packages) => {
+    const Builder = pkg.Builder;
+    const Field = pkg.Field;
+    const z = zod;
+    const builder = new Builder("testdb", ["classes", "spellLists", "spells"]);
+
+    const classStore = builder.defineModel("classes", {
+        id: Field.primaryKey().autoIncrement(),
+        name: Field.string(),
+        description: Field.string().array(),
+        spellList: Field.relation("spellLists", {
+            name: "spellList2class",
+        }).optional({ onDelete: "SetNull" }),
+    });
+
+    const spellListStore = builder.defineModel("spellLists", {
+        id: Field.primaryKey().autoIncrement(),
+        name: Field.string(),
+        class: Field.relation("classes", {
+            name: "spellList2class",
+            onDelete: "Cascade",
+        }).optional(),
+        spells: Field.relation("spells", {
+            name: "spells2spellLists",
+        }).array(),
+    });
+
+    const spellStore = builder.defineModel("spells", {
+        id: Field.primaryKey().autoIncrement(),
+        name: Field.string(),
+        range: Field.string(),
+        components: Field.custom(z.enum(["V", "S", "M"]).array()),
+        level: Field.number().default(0),
+        lists: Field.relation("spellLists", {
+            name: "spells2spellLists",
+        }).array(),
+    });
+
+    const db = builder.compile({
+        classes: classStore,
+        spellLists: spellListStore,
+        spells: spellStore,
+    });
+
+    const client = await db.createClient();
+    return client;
+};
+
+test.describe.configure({ mode: "default" });
+test.describe("1 page multi-test", () => {
+    let page: Page;
+    let session: ContextSession<SessionArguments>;
+    test.beforeAll(async ({ browser }) => {
+        const context = await browser.newContext();
+        page = await context.newPage();
+        session = await populatePage<SessionArguments>(page, {
+            pkg: "import('./index.js')",
+            zod: 'import("https://cdn.jsdelivr.net/npm/zod@4.1.12/+esm")',
+            client: createDb as any,
+        });
+    });
+
+    test.afterAll(async ({ browser }) => {
+        await browser.close();
+    });
+
+    test("Sample DB", async () => {
+        const result = await session.evaluate(async ({ client }) => {
+            const stores = client.stores;
+            await stores.spells.add({
+                name: "Acid Splash",
+                level: 0,
+                components: ["V"],
+                range: "15 feet",
+            });
+            await stores.spells.add({
+                name: "Chromatic Orb",
+                level: 1,
+                components: ["V", "S"],
+                range: "120 feet",
+            });
+            return await stores.spells.find({ where: { level: 0 } });
+        });
+        expect(result).toBeInstanceOf(Array);
+        expect(result.length === 1).toBeTruthy();
+    });
+});