@relations-dil/relations 0.1.0

package/dist/typed.js

@@ -0,0 +1,44 @@
+/**
+ * Typed models.
+ *
+ * Field values are reached through a Proxy at runtime, which TypeScript can't see into
+ * on its own. `fields()` closes that gap: it declares the fields once and hands back a
+ * base class that already knows their types.
+ *
+ * ```ts
+ * import { fields, int, str, list } from '@relations-dil/relations'
+ *
+ * class Unit extends fields({ id: int, name: str, tags: list }) {
+ *   static source = 'example'
+ * }
+ *
+ * const unit = await Unit.one({ name: 'yep' }).retrieve()
+ *
+ * unit.name.toUpperCase()   // string, checked
+ * unit.nmae                 // error: no such field
+ * unit.name = 5             // error: not a string
+ * ```
+ *
+ * Relations are declared separately from the model, so add them with `declare` when you
+ * want them typed too. `declare` is erased at compile time and costs nothing to run:
+ *
+ * ```ts
+ * class Unit extends fields({ id: int, name: str }) {
+ *   static source = 'example'
+ *   declare test: Test
+ * }
+ * ```
+ */
+import { Model } from './model.js';
+/**
+ * A base class with these fields, typed. Extend it instead of `Model` and every field
+ * is checked at the point you touch it. Pass a base to share configuration, the way a
+ * `Base` class shares a source across models.
+ */
+export function fields(spec, base = Model) {
+    class Fielded extends base {
+        static fields = spec;
+    }
+    return Fielded;
+}
+//# sourceMappingURL=typed.js.map

package/dist/util.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Small internal helpers. Nothing here is part of the public contract.
+ */
+/** Structural deep clone of plain data (objects, arrays, Sets, Dates, primitives). */
+export declare function clone<T>(value: T): T;
+/** Structural equality for exported values. Key order is ignored, array order is not. */
+export declare function equal(first: unknown, second: unknown): boolean;
+/** Stable JSON, used for unique index keys. */
+export declare function stable(value: unknown): string;
+/** Natural ascending sort: numbers numerically, everything else by string. */
+export declare function sorted<T>(values: Iterable<T>): T[];
+/** Three-way comparison used for sorting and ordering. */
+export declare function compare(first: any, second: any): number;
+/** Turn CamelCase into under_scored. */
+export declare function underscore(name: string): string;
+//# sourceMappingURL=util.d.ts.map

package/dist/util.js

@@ -0,0 +1,117 @@
+/**
+ * Small internal helpers. Nothing here is part of the public contract.
+ */
+import { isDict } from './overscore.js';
+/** Structural deep clone of plain data (objects, arrays, Sets, Dates, primitives). */
+export function clone(value) {
+    if (value === null || typeof value !== 'object') {
+        return value;
+    }
+    if (Array.isArray(value)) {
+        return value.map(clone);
+    }
+    if (value instanceof Set) {
+        return new Set([...value].map(clone));
+    }
+    if (value instanceof Map) {
+        return new Map([...value].map(([key, item]) => [clone(key), clone(item)]));
+    }
+    if (value instanceof Date) {
+        return new Date(value.getTime());
+    }
+    if (isDict(value)) {
+        const copy = {};
+        for (const key of Object.keys(value)) {
+            copy[key] = clone(value[key]);
+        }
+        return copy;
+    }
+    return value;
+}
+/** Structural equality for exported values. Key order is ignored, array order is not. */
+export function equal(first, second) {
+    if (first === second) {
+        return true;
+    }
+    if (first === null || second === null || first === undefined || second === undefined) {
+        return first == null && second == null;
+    }
+    if (typeof first !== 'object' || typeof second !== 'object') {
+        return false;
+    }
+    if (Array.isArray(first) || Array.isArray(second)) {
+        if (!Array.isArray(first) || !Array.isArray(second) || first.length !== second.length) {
+            return false;
+        }
+        return first.every((item, index) => equal(item, second[index]));
+    }
+    if (first instanceof Set || second instanceof Set) {
+        if (!(first instanceof Set) || !(second instanceof Set) || first.size !== second.size) {
+            return false;
+        }
+        return [...first].every((item) => second.has(item));
+    }
+    const firstKeys = Object.keys(first);
+    const secondKeys = Object.keys(second);
+    if (firstKeys.length !== secondKeys.length) {
+        return false;
+    }
+    return firstKeys.every((key) => Object.prototype.hasOwnProperty.call(second, key) &&
+        equal(first[key], second[key]));
+}
+/** Stable JSON, used for unique index keys. */
+export function stable(value) {
+    return JSON.stringify(value, (_key, item) => {
+        if (item instanceof Set) {
+            return sorted([...item]);
+        }
+        if (isDict(item)) {
+            const ordered = {};
+            for (const key of Object.keys(item).sort()) {
+                ordered[key] = item[key];
+            }
+            return ordered;
+        }
+        return item;
+    });
+}
+/** Natural ascending sort: numbers numerically, everything else by string. */
+export function sorted(values) {
+    return [...values].sort(compare);
+}
+/** Three-way comparison used for sorting and ordering. */
+export function compare(first, second) {
+    if (first === second) {
+        return 0;
+    }
+    if (first === null || first === undefined) {
+        return -1;
+    }
+    if (second === null || second === undefined) {
+        return 1;
+    }
+    if (typeof first === 'number' && typeof second === 'number') {
+        return first - second;
+    }
+    if (typeof first === 'boolean' && typeof second === 'boolean') {
+        return Number(first) - Number(second);
+    }
+    const firstText = String(first);
+    const secondText = String(second);
+    return firstText < secondText ? -1 : firstText > secondText ? 1 : 0;
+}
+/** Turn CamelCase into under_scored. */
+export function underscore(name) {
+    const parts = [];
+    let previous = true;
+    for (const letter of name) {
+        const lowered = letter.toLowerCase();
+        if (!previous && lowered !== letter) {
+            parts.push('_');
+        }
+        parts.push(lowered);
+        previous = lowered !== letter;
+    }
+    return parts.join('');
+}
+//# sourceMappingURL=util.js.map

package/package.json

@@ -0,0 +1,68 @@
+{
+  "name": "@relations-dil/relations",
+  "version": "0.1.0",
+  "description": "A simple, flexible DIL (data interface layer). Define models once, independent of backend; set the source at runtime.",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/relations-dil/typescript-relations.git"
+  },
+  "homepage": "https://github.com/relations-dil/typescript-relations#readme",
+  "bugs": {
+    "url": "https://github.com/relations-dil/typescript-relations/issues"
+  },
+  "keywords": [
+    "dil",
+    "orm",
+    "model",
+    "relations",
+    "database",
+    "microservice"
+  ],
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./mock": {
+      "types": "./dist/mock.d.ts",
+      "default": "./dist/mock.js"
+    },
+    "./overscore": {
+      "types": "./dist/overscore.d.ts",
+      "default": "./dist/overscore.js"
+    }
+  },
+  "files": [
+    "dist",
+    "!dist/**/*.map",
+    "README.md",
+    "LICENSE",
+    "CHANGELOG.md"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "clean": "rm -rf dist dist-test",
+    "typecheck": "tsc -p tsconfig.test.json",
+    "test": "node --import tsx --test test/*.test.ts",
+    "coverage": "tsc -p tsconfig.test.json --noEmit false --outDir dist-test && node --test --experimental-test-coverage --test-coverage-exclude='dist-test/test/**' --test-reporter=spec dist-test/test/*.test.js",
+    "lint": "npm run typecheck && eslint src test",
+    "example": "npm run build && for e in example/*.mjs; do echo \"== $e\"; node $e; done",
+    "prepublishOnly": "npm run build"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.39.5",
+    "@types/node": "^22.0.0",
+    "@unum-pillars/uikit": "^0.1.0",
+    "eslint": "^9.39.5",
+    "tsx": "^4.23.15",
+    "typescript": "^5.6.0",
+    "typescript-eslint": "^8.71.0"
+  }
+}