Copied from @mondoe/orm

Author: MechMel

.gitignore

@@ -0,0 +1 @@
+node_modules

OldLocalCache.ts

@@ -0,0 +1,3 @@
+# Mufasa
+
+A prototype local-first, reactive, highly-extensible, cross-backend, cross-frontend, cross-platform ORM. Very much a work in progress.

README.md

@@ -0,0 +1,6 @@
+import { GetClientStorage } from "./ClientStorage";
+export declare function capacitorStorage(fileSystem: {
+    readFile: (path: string) => Promise<string | undefined>;
+    writeFile: (path: string, data: string) => Promise<void>;
+    deleteFile: (path: string) => Promise<void>;
+}): GetClientStorage;

dist/ClientStorage/Capacitor.d.ts

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.capacitorStorage = void 0;
+const utils_1 = require("../utils");
+function capacitorStorage(fileSystem) {
+    return async function (fileName, init) {
+        fileName = `${fileName}.json`;
+        // Load data
+        let data = await (async () => {
+            const savedData = await fileSystem.readFile(fileName);
+            if ((0, utils_1.exists)(savedData)) {
+                return JSON.parse(savedData);
+            }
+            else {
+                return init;
+            }
+        })();
+        // Start save Loop
+        let saveIndex = 0;
+        let lastSaveIndex = saveIndex;
+        function requestSave() {
+            saveIndex += 1;
+        }
+        (async () => {
+            while (true) {
+                if (lastSaveIndex !== saveIndex) {
+                    lastSaveIndex = saveIndex;
+                    await fileSystem.writeFile(fileName, JSON.stringify(data));
+                }
+                await new Promise((resolve) => setTimeout(resolve, 250));
+            }
+        })();
+        // Return interface
+        return {
+            // Adds and updates the given data
+            updateData: ((updates) => {
+                updateRec(data, updates);
+                requestSave();
+                function updateRec(original, updates) {
+                    for (const propName in updates) {
+                        const value = updates[propName];
+                        if (value === undefined) {
+                            // Undefined means delete
+                            delete original[propName];
+                        }
+                        else if (typeof value === "object" &&
+                            value !== null &&
+                            !Array.isArray(value)) {
+                            // Objects
+                            if (!(0, utils_1.exists)(original[propName]) ||
+                                typeof original[propName] !== "object" ||
+                                Array.isArray(original[propName]) ||
+                                original[propName] === null) {
+                                original[propName] = {};
+                            }
+                            updateRec(original[propName], value);
+                        }
+                        else {
+                            // Primitives
+                            original[propName] = value;
+                        }
+                    }
+                }
+            }),
+            /** Readonly access to the data. */
+            data: data,
+            // File operations
+            readFile: fileSystem.readFile,
+            writeFile: fileSystem.writeFile,
+            deleteFile: fileSystem.deleteFile,
+        };
+    };
+}
+exports.capacitorStorage = capacitorStorage;

dist/ClientStorage/Capacitor.js

@@ -0,0 +1,19 @@
+export type Json = number | string | boolean | null | undefined | JsonObject;
+export type JsonObject = {
+    [propName: string]: Json;
+};
+export type GetClientStorage = <T extends JsonObject>(fileName: string, init: T) => Promise<ClientStorage<T>>;
+type DeepReadonlyJsonObject<T> = T extends object ? {
+    readonly [K in keyof T]: DeepReadonlyJsonObject<T[K]>;
+} : T;
+type SpecificJsonObject<T extends JsonObject> = DeepReadonlyJsonObject<Partial<T>>;
+export type ClientStorage<T extends JsonObject> = {
+    /** Adds and updates the given data */
+    updateData(updates: SpecificJsonObject<T>): void;
+    /** Readonly access to the data. */
+    data: SpecificJsonObject<T>;
+    readFile: (path: string) => Promise<string | undefined>;
+    writeFile: (path: string, data: string) => Promise<void>;
+    deleteFile: (path: string) => Promise<void>;
+};
+export {};

dist/ClientStorage/ClientStorage.d.ts

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

dist/ClientStorage/ClientStorage.js

@@ -0,0 +1,46 @@
+import { _Doc, _List, _defineAppDataStructure } from "./Implement";
+import { capacitorStorage as _capacitorStorage } from "./ClientStorage/Capacitor";
+/** We should look into how drizzle orm handles definitions to get some inspiration for how to clean ours up. */
+export type Doc<T extends {} = {}> = _Doc<T>;
+export type List<T extends _Doc<{}> = _Doc<{}>> = _List<T>;
+export declare const defineAppDataStructure: typeof _defineAppDataStructure;
+export declare const capacitorStorage: typeof _capacitorStorage;
+/** Defines a prop of the specified primitive type. */
+export declare function prim<T extends number | string | boolean>(
+/** TODO: We might consider using Number, String, or Boolean as the first parameter
+ * instead. */
+defaultValue: T | null | (() => T | null)): {
+    format: "prim";
+    refTypeName: undefined;
+    primType: T;
+    isList: false;
+    isDefining: false;
+    defaultValue: T | (() => T | null) | null;
+};
+/** Defines a prop that references a doc. */
+export declare function refTo<T extends string>(table: T, defaultValue?: string | null): {
+    format: "one";
+    refTypeName: T;
+    primType: undefined;
+    isList: false;
+    isDefining: false;
+    defaultValue: string | null;
+};
+/** Defines a list of docs that point back to this doc. */
+export declare function listOf<T extends string>(table: T): {
+    format: "many";
+    refTypeName: T;
+    primType: undefined;
+    isList: true;
+    isDefining: true;
+    defaultValue: undefined;
+};
+/** Defines a prop that references a file. */
+export declare function file(defaultValue?: string | null): {
+    format: "file";
+    refTypeName: undefined;
+    primType: undefined;
+    isList: false;
+    isDefining: false;
+    defaultValue: string | null;
+};

dist/Define.d.ts

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.file = exports.listOf = exports.refTo = exports.prim = exports.capacitorStorage = exports.defineAppDataStructure = void 0;
+const Implement_1 = require("./Implement");
+const Capacitor_1 = require("./ClientStorage/Capacitor");
+exports.defineAppDataStructure = Implement_1._defineAppDataStructure;
+exports.capacitorStorage = Capacitor_1.capacitorStorage;
+/** Defines a prop of the specified primitive type. */
+function prim(
+/** TODO: We might consider using Number, String, or Boolean as the first parameter
+ * instead. */
+defaultValue) {
+    return {
+        format: `prim`,
+        refTypeName: undefined,
+        primType: {},
+        isList: false,
+        isDefining: false,
+        defaultValue: defaultValue,
+    };
+}
+exports.prim = prim;
+/** Defines a prop that references a doc. */
+function refTo(table, defaultValue = null) {
+    return {
+        format: `one`,
+        refTypeName: table,
+        primType: undefined,
+        isList: false,
+        isDefining: false,
+        defaultValue: defaultValue,
+    };
+}
+exports.refTo = refTo;
+/** Defines a list of docs that point back to this doc. */
+function listOf(table) {
+    return {
+        format: `many`,
+        refTypeName: table,
+        primType: undefined,
+        isList: true,
+        isDefining: true,
+        defaultValue: undefined,
+    };
+}
+exports.listOf = listOf;
+/** Defines a prop that references a file. */
+function file(defaultValue = null) {
+    return {
+        format: `file`,
+        refTypeName: undefined,
+        primType: undefined,
+        isList: false,
+        isDefining: false,
+        defaultValue: defaultValue,
+    };
+}
+exports.file = file;

dist/Define.js

@@ -0,0 +1,46 @@
+import { FirebaseOptions } from "firebase/app";
+import { SchemaDictToTsType, SchemaToTsType, TypeSchemaDict, RootSchema } from "./Parse";
+import { LocalCache } from "./LocalCache";
+import { GetClientStorage } from "./ClientStorage/ClientStorage";
+export type Computed<T> = {
+    get value(): T;
+};
+export type Signal<T> = {
+    set value(newValue: T);
+} & Computed<T>;
+declare let _computed: <T>(compute: () => T) => Computed<T>;
+declare let _signal: <T>(initialValue: T) => Signal<T>;
+declare let _isSignal: (obj: any) => obj is Signal<any>;
+declare let _watchEffect: (effect: () => void) => void;
+export type _Doc<T extends {} = {}> = {
+    [K in keyof T]: T[K] | undefined;
+} & _DocSpecificProps;
+export type _DocSpecificProps = {
+    readonly _id: string | null | undefined;
+    readonly isLoaded: boolean;
+    readonly isDeleted: boolean;
+    deleteDoc(): Promise<void>;
+};
+export declare function docProx<TypeName extends string, F extends TypeSchemaDict, T extends _Doc<{}> = SchemaToTsType<TypeName, F>>(docId: string | null | undefined, typeName: TypeName, objFormats: F, localCache: LocalCache): T;
+export type _List<T extends _Doc> = {
+    [Symbol.iterator]: () => IterableIterator<T>;
+    readonly length: number;
+    filter(filterFn: (doc: T) => boolean): _List<T>;
+    map<R>(mapFn: (doc: T) => R): Array<R>;
+    add(params: Partial<T>): T;
+};
+export declare function _defineAppDataStructure<RS extends RootSchema, TSD extends TypeSchemaDict>(modelName: string, firebaseOptions: FirebaseOptions, reactivity: {
+    computed: typeof _computed;
+    signal: typeof _signal;
+    isSignal: typeof _isSignal;
+    watchEffect: typeof _watchEffect;
+}, options: {
+    isProduction: boolean;
+    getClientStorage: GetClientStorage;
+    rootSchema: RS;
+    typeSchemas: TSD;
+}): {
+    getAppData: () => { [K in keyof RS]: _List<SchemaToTsType<NonNullable<RS[K]["refTypeName"]>, TSD>>; };
+    types: SchemaDictToTsType<TSD>;
+};
+export {};