@lix-js/sdk 0.6.0-preview.4 → 0.6.0

package/dist/value.js

@@ -0,0 +1,245 @@
+import { invalidParam } from "./errors.js";
+export class Value {
+    kind;
+    #raw;
+    constructor(raw) {
+        validateExplicitValue(raw);
+        this.#raw = cloneValue(raw);
+        this.kind = this.#raw.kind;
+    }
+    static null() {
+        return new Value({ kind: "null", value: null });
+    }
+    static boolean(value) {
+        return new Value({ kind: "boolean", value });
+    }
+    static integer(value) {
+        return new Value({ kind: "integer", value });
+    }
+    static real(value) {
+        return new Value({ kind: "real", value });
+    }
+    static text(value) {
+        return new Value({ kind: "text", value });
+    }
+    static json(value) {
+        return new Value({ kind: "json", value });
+    }
+    static blob(value) {
+        return new Value({ kind: "blob", value });
+    }
+    static from(value) {
+        return new Value(normalizeParam(value));
+    }
+    static _fromNative(value) {
+        return new Value(value);
+    }
+    _toNative() {
+        return toNativeValue(this.#raw);
+    }
+    toJS() {
+        return unwrapValue(this.#raw);
+    }
+    asBytes() {
+        if (this.#raw.kind !== "blob")
+            return undefined;
+        return new Uint8Array(this.#raw.value);
+    }
+}
+export function toNativeValue(value) {
+    if (value.kind !== "blob")
+        return value;
+    return {
+        kind: "blob",
+        value: null,
+        blob: new Uint8Array(value.value),
+    };
+}
+export function fromNativeValue(value) {
+    if (value.kind !== "blob")
+        return value;
+    return {
+        kind: "blob",
+        value: new Uint8Array(value.blob),
+    };
+}
+export function normalizeParam(value, index = 0, seen = new WeakSet()) {
+    if (value instanceof Value)
+        return fromNativeValue(value._toNative());
+    if (value === null)
+        return { kind: "null", value: null };
+    if (typeof value === "boolean")
+        return { kind: "boolean", value };
+    if (typeof value === "string") {
+        if (!isWellFormedString(value)) {
+            throw invalidParam(index, "string SQL parameters must be well-formed UTF-16", "string");
+        }
+        return { kind: "text", value };
+    }
+    if (typeof value === "number") {
+        if (!Number.isFinite(value)) {
+            throw invalidParam(index, "number SQL parameters must be a finite number", "number");
+        }
+        if (Number.isInteger(value) && !Number.isSafeInteger(value)) {
+            throw invalidParam(index, "integer SQL parameters must be a safe integer", "number");
+        }
+        return Number.isSafeInteger(value)
+            ? { kind: "integer", value }
+            : { kind: "real", value };
+    }
+    if (value instanceof Uint8Array) {
+        return {
+            kind: "blob",
+            value: new Uint8Array(value),
+        };
+    }
+    if (typeof value === "object" && value) {
+        if (value instanceof Date) {
+            throw invalidParam(index, "Date is not a valid SQL parameter", "Date");
+        }
+        if (ArrayBuffer.isView(value)) {
+            throw invalidParam(index, "typed array SQL parameters must be Uint8Array", value.constructor.name);
+        }
+        assertJsonSerializable(value, seen, index);
+        return { kind: "json", value };
+    }
+    throw invalidParam(index, `${typeof value} is not a valid SQL parameter`, typeof value);
+}
+function unwrapValue(value) {
+    switch (value.kind) {
+        case "null":
+            return null;
+        case "boolean":
+        case "integer":
+        case "real":
+        case "text":
+        case "json":
+            return cloneJsonValue(value.value);
+        case "blob":
+            return new Uint8Array(value.value);
+        default:
+            return undefined;
+    }
+}
+function assertJsonSerializable(value, seen, index) {
+    if (value === null)
+        return;
+    if (typeof value === "string") {
+        if (!isWellFormedString(value)) {
+            throw invalidParam(index, "string SQL parameters must be well-formed UTF-16", "string");
+        }
+        return;
+    }
+    if (typeof value === "number") {
+        if (!Number.isFinite(value)) {
+            throw invalidParam(index, "number SQL parameters must be a finite number", "number");
+        }
+        if (Number.isInteger(value) && !Number.isSafeInteger(value)) {
+            throw invalidParam(index, "integer SQL parameters must be a safe integer", "number");
+        }
+        return;
+    }
+    if (typeof value === "boolean")
+        return;
+    if (typeof value !== "object") {
+        throw invalidParam(index, `${typeof value} is not a valid SQL parameter`, typeof value);
+    }
+    if (value instanceof Value) {
+        throw invalidParam(index, "Value is only valid as a top-level SQL parameter", "Value");
+    }
+    if (value instanceof Date) {
+        throw invalidParam(index, "Date is not a valid SQL parameter", "Date");
+    }
+    if (ArrayBuffer.isView(value)) {
+        throw invalidParam(index, "typed array SQL parameters must be top-level Uint8Array values", value.constructor.name);
+    }
+    if (!Array.isArray(value) && !isPlainObject(value)) {
+        throw invalidParam(index, "object SQL parameters must be JSON-compatible plain objects or arrays", value.constructor?.name ?? "object");
+    }
+    if (seen.has(value)) {
+        throw invalidParam(index, "JSON SQL parameters cannot contain circular references", "object");
+    }
+    seen.add(value);
+    const entries = Array.isArray(value) ? value : Object.values(value);
+    for (const entry of entries) {
+        assertJsonSerializable(entry, seen, index);
+    }
+    seen.delete(value);
+}
+function validateExplicitValue(value) {
+    switch (value.kind) {
+        case "null":
+            if (value.value !== null)
+                break;
+            return;
+        case "boolean":
+            if (typeof value.value !== "boolean")
+                break;
+            return;
+        case "integer":
+            if (typeof value.value === "number" &&
+                Number.isSafeInteger(value.value)) {
+                return;
+            }
+            break;
+        case "real":
+            if (typeof value.value === "number" && Number.isFinite(value.value))
+                return;
+            break;
+        case "text":
+            if (typeof value.value !== "string")
+                break;
+            if (!isWellFormedString(value.value)) {
+                throw invalidParam(0, "string SQL parameters must be well-formed UTF-16", "string");
+            }
+            return;
+        case "json":
+            assertJsonSerializable(value.value, new WeakSet(), 0);
+            return;
+        case "blob":
+            if (value.value instanceof Uint8Array)
+                return;
+            break;
+        default:
+            break;
+    }
+    throw invalidParam(0, "explicit Value contains an invalid native value", "Value");
+}
+function cloneValue(value) {
+    if (value.kind === "blob") {
+        return { kind: "blob", value: new Uint8Array(value.value) };
+    }
+    if (value.kind === "json") {
+        return { kind: "json", value: cloneJsonValue(value.value) };
+    }
+    return value;
+}
+function cloneJsonValue(value) {
+    if (Array.isArray(value))
+        return value.map(cloneJsonValue);
+    if (value && typeof value === "object") {
+        return Object.fromEntries(Object.entries(value).map(([key, entry]) => [key, cloneJsonValue(entry)]));
+    }
+    return value;
+}
+function isPlainObject(value) {
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+}
+function isWellFormedString(value) {
+    if (typeof value.isWellFormed === "function")
+        return value.isWellFormed();
+    for (let index = 0; index < value.length; index += 1) {
+        const code = value.charCodeAt(index);
+        if (code >= 0xd800 && code <= 0xdbff) {
+            const next = value.charCodeAt(index + 1);
+            if (!(next >= 0xdc00 && next <= 0xdfff))
+                return false;
+            index += 1;
+        }
+        else if (code >= 0xdc00 && code <= 0xdfff) {
+            return false;
+        }
+    }
+    return true;
+}

package/package.json

@@ -1,69 +1,39 @@
 {
 	"name": "@lix-js/sdk",
 	"type": "module",
-	"version": "0.6.0-preview.4",
+	"version": "0.6.0",
 	"main": "./dist/index.js",
 	"types": "./dist/index.d.ts",
-	"files": [
-		"dist",
-		"dist-engine-src",
-		"SKILL.md"
-	],
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/opral/lix"
+	},
 	"exports": {
 		".": {
 			"types": "./dist/index.d.ts",
 			"default": "./dist/index.js"
-		},
-		"./sqlite": {
-			"types": "./dist/sqlite/index.d.ts",
-			"default": "./dist/sqlite/index.js"
 		}
 	},
-	"description": "WASM-backed JS SDK wrapper for Lix",
+	"files": [
+		"dist"
+	],
 	"scripts": {
-		"build": "node ./scripts/build.js",
-		"sync:builtin-schemas": "node ./scripts/sync-builtin-schemas.js",
-		"sync:engine-src": "node ./scripts/sync-engine-src.js",
-		"prepack": "node ./scripts/sync-engine-src.js",
-		"typecheck": "pnpm run sync:builtin-schemas && tsc -p tsconfig.json --noEmit",
-		"test": "node ./scripts/build.js && vitest run",
-		"test:watch": "node ./scripts/build.js && vitest"
+		"build": "npm run build:native && npm run build:ts",
+		"build:native": "node ./scripts/build-native.js",
+		"prepare:native-package": "node ./scripts/prepare-native-package.js",
+		"build:ts": "tsc -p tsconfig.json",
+		"test": "npm run build && vitest run",
+		"typecheck": "tsc -p tsconfig.test.json --noEmit"
 	},
-	"peerDependencies": {
-		"better-sqlite3": "^12.9.0"
-	},
-	"peerDependenciesMeta": {
-		"better-sqlite3": {
-			"optional": true
-		}
+	"optionalDependencies": {
+		"@lix-js/sdk-darwin-arm64": "0.6.0",
+		"@lix-js/sdk-linux-arm64": "0.6.0",
+		"@lix-js/sdk-linux-x64": "0.6.0",
+		"@lix-js/sdk-win32-x64": "0.6.0"
 	},
 	"devDependencies": {
-		"better-sqlite3": "^12.9.0",
+		"@types/node": "^24.10.2",
 		"typescript": "^5.5.4",
 		"vitest": "^4.0.18"
-	},
-	"nx": {
-		"targets": {
-			"build": {
-				"inputs": [
-					"default",
-					"^default",
-					"publicEnv",
-					"nodeVersion",
-					"platform",
-					"{workspaceRoot}/Cargo.toml",
-					"{workspaceRoot}/Cargo.lock",
-					"{workspaceRoot}/packages/engine/**/*",
-					"{workspaceRoot}/packages/rs-sdk/**/*",
-					"{workspaceRoot}/packages/js-sdk/Cargo.toml",
-					"{workspaceRoot}/packages/js-sdk/wasm-bindgen.rs"
-				],
-				"outputs": [
-					"{projectRoot}/dist",
-					"{projectRoot}/dist-engine-src",
-					"{projectRoot}/src/engine-wasm/wasm"
-				]
-			}
-		}
 	}
 }