@idb-orm/core 1.0.3 → 1.0.4

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

@@ -1,125 +1,38 @@
 import { CompiledDb } from "../builder.js";
-import {
-    BaseRelation,
-    Field,
-    OptionalRelation,
-    PrimaryKey,
-    Relation,
-    RelationArray,
-    RelationOutput,
-    ValidValue,
-} from "../field/index.js";
+import { BaseRelation, Field, OptionalRelation, PrimaryKey, Relation, RelationArray, RelationOutput, ValidValue } from "../field";
 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 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;
+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 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>;
+    [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;
+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

@@ -1,20 +1,10 @@
 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 { BaseRelation, Field, FieldTypes, PrimaryKey, ValidValue } from "../field";
 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>
-> {
+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;
@@ -25,18 +15,10 @@ export default class Model<
     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;
+    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>;
+    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

@@ -1,10 +1,9 @@
 /**
  * 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";
+import { Dict, Promisable, ValidKey } from "./types/common.js";
 export declare class ObjectStore {
     private readonly tx;
     readonly store: IDBObjectStore;

package/dist/transaction.d.ts

@@ -1,21 +1,15 @@
-import type { Arrayable } from "type-fest";
-import { StoreError } from "./error.js";
+import { StoreError } from "./error";
 import { ObjectStore } from "./object-store.js";
+import { Arrayable } from "./types/common.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
-> {
+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;
@@ -24,12 +18,7 @@ export declare class Transaction<
      * A record of store names to `IDBObjectStore` objects
      */
     private readonly objectStores;
-    constructor(
-        db: IDBDatabase,
-        stores: Arrayable<Stores>,
-        mode: Mode,
-        options?: TransactionOptions
-    );
+    constructor(db: IDBDatabase, stores: Arrayable<Stores>, mode: Mode, options?: TransactionOptions);
     abort(error: StoreError): StoreError;
     commit(): void;
     /**

package/dist/types/common.d.ts

@@ -1,9 +1,11 @@
-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 Arrayable<T> = T | T[];
+export type IsNever<T> = [T] extends [never] ? true : false;
+export type Promisable<T> = T | Promise<T>;
 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;
@@ -34,4 +36,5 @@ 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 type Literable = string | number | bigint | boolean | null | undefined;
 export {};

package/dist/utils.d.ts

@@ -1,5 +1,4 @@
-import type { Keyof } from "./types/common";
-import type { Arrayable } from "type-fest";
+import type { Arrayable, Keyof } from "./types/common";
 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>[];

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@idb-orm/core",
-    "version": "1.0.3",
+    "version": "1.0.4",
     "description": "",
     "main": "dist/index.js",
     "type": "module",

package/eslint.config.js

@@ -1,55 +0,0 @@
-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/playwright.config.ts

@@ -1,79 +0,0 @@
-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

@@ -1,72 +0,0 @@
-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

@@ -1,101 +0,0 @@
-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();
-    });
-});