data-of-loathing 2.6.2 → 3.0.0

package/dist/BaseClient.d.ts

@@ -0,0 +1,14 @@
+import { type EntityManager, MikroORM } from "@mikro-orm/core";
+export declare const DEFAULT_URL = "https://data.loathers.net/dol.sqlite";
+export declare const ETAG_KEY = "dol-etag";
+export declare abstract class BaseClient<S> {
+    protected _orm?: MikroORM;
+    protected readonly _strategy: S;
+    constructor(strategy: S);
+    get query(): EntityManager;
+    abstract load(): Promise<void>;
+    protected fetchDb(url: string): Promise<ArrayBuffer>;
+    protected abstract getStoredEtag(key: string): Promise<string | null>;
+    protected abstract storeEtag(key: string, etag: string): Promise<void>;
+    protected syncIfNeeded(url: string, key: string, apply: (data: ArrayBuffer) => Promise<void>, force?: boolean): Promise<void>;
+}

package/dist/BaseClient.js

@@ -0,0 +1,30 @@
+export const DEFAULT_URL = "https://data.loathers.net/dol.sqlite";
+export const ETAG_KEY = "dol-etag";
+export class BaseClient {
+    _orm;
+    _strategy;
+    constructor(strategy) {
+        this._strategy = strategy;
+    }
+    get query() {
+        if (!this._orm)
+            throw new Error("Call await client.load() before querying");
+        return this._orm.em;
+    }
+    async fetchDb(url) {
+        const response = await fetch(url);
+        if (!response.ok)
+            throw new Error(`Failed to fetch database: ${response.status}`);
+        return response.arrayBuffer();
+    }
+    async syncIfNeeded(url, key, apply, force = false) {
+        const storedEtag = force ? null : await this.getStoredEtag(key);
+        const head = await fetch(url, { method: "HEAD" });
+        const remoteEtag = head.headers.get("etag");
+        if (force || storedEtag !== remoteEtag) {
+            await apply(await this.fetchDb(url));
+            if (remoteEtag)
+                await this.storeEtag(key, remoteEtag);
+        }
+    }
+}

package/dist/browser-client.d.ts

@@ -0,0 +1,17 @@
+import { type EntityManager } from "@mikro-orm/core";
+export type Strategy = {
+    strategy?: "cache";
+    url?: string;
+} | {
+    strategy: "remote";
+    url?: string;
+};
+export declare class Client {
+    private _orm?;
+    private readonly _strategy;
+    constructor(strategy?: Strategy);
+    get em(): EntityManager;
+    load(): Promise<void>;
+    private _db?;
+}
+export declare function createClient(strategy?: Strategy): Client;

package/dist/browser-client.js

@@ -0,0 +1,58 @@
+import { SqlMikroORM, SqliteDriver } from "@mikro-orm/sql";
+import { HttpVFSDialect } from "./http-vfs-dialect.js";
+import { entities } from "data-of-loathing-schema";
+const DEFAULT_URL = "https://data.loathers.net/dol.sqlite";
+const ETAG_KEY = "dol-etag";
+export class Client {
+    _orm;
+    _strategy;
+    constructor(strategy = {}) {
+        this._strategy = strategy;
+    }
+    get em() {
+        if (!this._orm)
+            throw new Error("Call await client.load() before querying");
+        return this._orm.em;
+    }
+    async load() {
+        await this._orm?.close();
+        const url = this._strategy.url ?? DEFAULT_URL;
+        if (this._strategy.strategy === "remote") {
+            this._orm = await SqlMikroORM.init({
+                driver: SqliteDriver,
+                driverOptions: new HttpVFSDialect(url),
+                dbName: url,
+                entities,
+                allowGlobalContext: true,
+            });
+            return;
+        }
+        const { SQLocalKysely } = await import("sqlocal/kysely");
+        if (!this._db) {
+            this._db = new SQLocalKysely("dol.sqlite");
+        }
+        const storedEtag = localStorage.getItem(ETAG_KEY);
+        const head = await fetch(url, { method: "HEAD" });
+        const remoteEtag = head.headers.get("etag");
+        if (!storedEtag || storedEtag !== remoteEtag) {
+            const response = await fetch(url);
+            if (!response.ok)
+                throw new Error(`Failed to fetch database: ${response.status}`);
+            await this._db.overwriteDatabaseFile(await response.arrayBuffer());
+            if (remoteEtag)
+                localStorage.setItem(ETAG_KEY, remoteEtag);
+        }
+        this._orm = await SqlMikroORM.init({
+            driver: SqliteDriver,
+            driverOptions: this._db.dialect,
+            dbName: "dol.sqlite",
+            entities,
+            allowGlobalContext: true,
+        });
+    }
+    // sqlocal instance kept across load() calls to preserve OPFS connection
+    _db;
+}
+export function createClient(strategy = {}) {
+    return new Client(strategy);
+}

package/dist/browser-strategies.d.ts

@@ -0,0 +1,9 @@
+export declare const DEFAULT_URL = "https://data.loathers.net/data-of-loathing.sqlite";
+export type BrowserStrategy = {
+    strategy?: "cache";
+    url?: string;
+} | {
+    strategy: "remote";
+    url?: string;
+};
+export declare function resolveDbPath(opts: BrowserStrategy): Promise<string>;

package/dist/browser-strategies.js

@@ -0,0 +1,37 @@
+export const DEFAULT_URL = "https://data.loathers.net/data-of-loathing.sqlite";
+const OPFS_FILENAME = "data-of-loathing.sqlite";
+const ETAG_KEY = "data-of-loathing-etag";
+async function writeToOpfs(data) {
+    const root = await navigator.storage.getDirectory();
+    const handle = await root.getFileHandle(OPFS_FILENAME, { create: true });
+    const writable = await handle.createWritable();
+    await writable.write(data);
+    await writable.close();
+}
+async function opfsFileExists() {
+    try {
+        const root = await navigator.storage.getDirectory();
+        await root.getFileHandle(OPFS_FILENAME);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function resolveDbPath(opts) {
+    if (opts.strategy === "remote")
+        throw new Error("HTTP range request strategy not yet implemented");
+    const url = opts.url ?? DEFAULT_URL;
+    const storedEtag = localStorage.getItem(ETAG_KEY);
+    const head = await fetch(url, { method: "HEAD" });
+    const remoteEtag = head.headers.get("etag");
+    if (!(await opfsFileExists()) || storedEtag !== remoteEtag) {
+        const response = await fetch(url);
+        if (!response.ok)
+            throw new Error(`Failed to fetch database: ${response.status}`);
+        await writeToOpfs(await response.arrayBuffer());
+        if (remoteEtag)
+            localStorage.setItem(ETAG_KEY, remoteEtag);
+    }
+    return OPFS_FILENAME;
+}

package/dist/browser.d.ts

@@ -0,0 +1,15 @@
+import { BaseClient } from "./BaseClient.js";
+export type Strategy = {
+    strategy?: "url";
+    url?: string;
+    force?: boolean;
+};
+export declare class Client extends BaseClient<Strategy> {
+    private _db?;
+    constructor(strategy?: Strategy);
+    protected getStoredEtag(_key: string): Promise<string | null>;
+    protected storeEtag(_key: string, etag: string): Promise<void>;
+    load(): Promise<void>;
+}
+export declare function createClient(strategy?: Strategy): Client;
+export * from "data-of-loathing-schema";

package/dist/browser.js

@@ -0,0 +1,35 @@
+import { SqlMikroORM, SqliteDriver } from "@mikro-orm/sql";
+import { SQLocalKysely } from "sqlocal/kysely";
+import { entities } from "data-of-loathing-schema";
+import { BaseClient, DEFAULT_URL, ETAG_KEY } from "./BaseClient.js";
+export class Client extends BaseClient {
+    _db;
+    constructor(strategy = {}) {
+        super(strategy);
+    }
+    async getStoredEtag(_key) {
+        return localStorage.getItem(ETAG_KEY);
+    }
+    async storeEtag(_key, etag) {
+        localStorage.setItem(ETAG_KEY, etag);
+    }
+    async load() {
+        await this._orm?.close();
+        const url = this._strategy.url ?? DEFAULT_URL;
+        if (!this._db) {
+            this._db = new SQLocalKysely("dol.sqlite");
+        }
+        await this.syncIfNeeded(url, ETAG_KEY, (data) => this._db.overwriteDatabaseFile(data), this._strategy.force);
+        this._orm = await SqlMikroORM.init({
+            driver: SqliteDriver,
+            driverOptions: this._db.dialect,
+            dbName: "dol.sqlite",
+            entities,
+            allowGlobalContext: true,
+        });
+    }
+}
+export function createClient(strategy = {}) {
+    return new Client(strategy);
+}
+export * from "data-of-loathing-schema";

package/dist/client.d.ts

@@ -0,0 +1,11 @@
+import type { EntityManager } from "@mikro-orm/core";
+import { type Strategy } from "./strategies.js";
+export type { Strategy };
+export declare class Client {
+    private _orm?;
+    private readonly _strategy;
+    constructor(strategy?: Strategy);
+    get em(): EntityManager;
+    load(): Promise<void>;
+}
+export declare function createClient(strategy?: Strategy): Client;

package/dist/client.js

@@ -0,0 +1,29 @@
+import { NodeSqliteDialect, SqliteDriver, SqlMikroORM } from "@mikro-orm/sql";
+import { entities } from "data-of-loathing-schema";
+import { resolveDbPath } from "./strategies.js";
+export class Client {
+    _orm;
+    _strategy;
+    constructor(strategy = {}) {
+        this._strategy = strategy;
+    }
+    get em() {
+        if (!this._orm)
+            throw new Error("Call await client.load() before querying");
+        return this._orm.em;
+    }
+    async load() {
+        await this._orm?.close();
+        const path = await resolveDbPath(this._strategy);
+        this._orm = await SqlMikroORM.init({
+            driver: SqliteDriver,
+            driverOptions: new NodeSqliteDialect(path),
+            dbName: path,
+            entities,
+            allowGlobalContext: true,
+        });
+    }
+}
+export function createClient(strategy = {}) {
+    return new Client(strategy);
+}

package/dist/http-range-worker.d.ts

@@ -0,0 +1 @@
+export {};