@inlang/sdk 0.36.2 → 2.0.0-prerelease.0

package/package.json

@@ -1,69 +1,67 @@
 {
   "name": "@inlang/sdk",
+  "version": "2.0.0-prerelease.0",
   "type": "module",
-  "version": "0.36.2",
-  "license": "Apache-2.0",
+  "license": "MIT",
   "publishConfig": {
     "access": "public"
   },
   "homepage": "https://inlang.com/documentation/sdk",
   "repository": {
     "type": "git",
-    "url": "https://github.com/opral/inlang-message-sdk"
+    "url": "https://github.com/opral/inlang-sdk"
   },
   "exports": {
     ".": "./dist/index.js",
-    "./test-utilities": "./dist/test-utilities/index.js",
-    "./lint": "./dist/lint/index.js",
-    "./messages": "./dist/messages/index.js",
-    "./v2": "./dist/v2/index.js",
-    "./v2-mocks": "./dist/v2/mocks/index.js"
+    "./settings-schema": "./src/json-schema/settings.ts"
   },
   "files": [
     "./dist",
     "./src"
   ],
+  "_comment": "Required for tree-shaking https://webpack.js.org/guides/tree-shaking/#mark-the-file-as-side-effect-free",
+  "sideEffects": false,
   "engines": {
     "node": ">=18.0.0"
   },
+  "bundleDependencies": [
+    "@lix-js/sdk",
+    "sqlite-wasm-kysely"
+  ],
   "dependencies": {
+    "@sentry/browser": "^7.118.0",
     "@sinclair/typebox": "^0.31.17",
-    "debug": "^4.3.4",
     "dedent": "1.5.1",
-    "deepmerge-ts": "^5.1.0",
-    "murmurhash3js": "^3.0.1",
-    "solid-js": "1.6.12",
-    "throttle-debounce": "^5.0.0",
-    "@inlang/json-types": "1.1.0",
-    "@inlang/language-tag": "1.5.1",
-    "@inlang/message": "2.1.0",
-    "@inlang/message-lint-rule": "1.4.7",
-    "@inlang/plugin": "2.4.13",
-    "@inlang/module": "1.2.13",
-    "@inlang/project-settings": "2.4.2",
-    "@inlang/result": "1.1.0",
-    "@inlang/translatable": "1.3.1",
-    "@lix-js/fs": "2.1.0",
-    "@lix-js/client": "2.2.0"
+    "kysely": "^0.27.4",
+    "rxjs": "7.8.1",
+    "uuid": "^10.0.0",
+    "readdirp": "^4.0.1",
+    "@lix-js/sdk": "0.1.0",
+    "sqlite-wasm-kysely": "0.1.0"
   },
   "devDependencies": {
-    "@types/debug": "^4.1.12",
-    "@types/murmurhash3js": "^3.0.7",
-    "@types/throttle-debounce": "5.0.0",
-    "@vitest/coverage-v8": "^0.33.0",
-    "jsdom": "22.1.0",
-    "patch-package": "6.5.1",
-    "tsd": "^0.25.0",
+    "@eslint/js": "^9.12.0",
+    "@sentry/cli": "^2.35.0",
+    "@types/node": "^22.5.1",
+    "@types/uuid": "^10.0.0",
+    "@vitest/coverage-v8": "^2.0.5",
+    "eslint": "^9.12.0",
+    "typescript-eslint": "^8.9.0",
+    "memfs": "4.6.0",
     "typescript": "^5.5.2",
-    "vitest": "^0.33.0"
+    "vitest": "^2.0.5",
+    "@opral/tsconfig": "1.0.0"
   },
   "scripts": {
-    "build": "npm run prepare-env-variables && tsc --build",
-    "dev": "npm run prepare-env-variables && tsc --watch",
-    "prepare-env-variables": "node ./src/env-variables/createIndexFile.js",
-    "test": "npm run prepare-env-variables && tsc --noEmit && vitest run --passWithNoTests --coverage",
-    "lint": "eslint ./src --fix",
+    "prepublish": "npm run sentry:sourcemaps",
+    "build": "npm run env-variables && tsc --build",
+    "dev": "npm run env-variables && tsc --watch",
+    "env-variables": "node ./src/services/env-variables/createIndexFile.js",
+    "test": "tsc --noEmit && vitest run",
+    "test:watch": "vitest",
+    "lint": "eslint ./src",
     "format": "prettier ./src --write",
-    "clean": "rm -rf ./dist ./node_modules"
+    "clean": "rm -rf ./dist ./node_modules",
+    "sentry:sourcemaps": "sentry-cli sourcemaps inject --org opral --project inlang-sdk ./dist && sentry-cli sourcemaps upload --org opral --project inlang-sdk ./dist"
   }
 }

package/src/database/initDb.ts

@@ -0,0 +1,34 @@
+import { CamelCasePlugin, Kysely } from "kysely";
+import { applySchema, type InlangDatabaseSchema } from "./schema.js";
+import { createDialect, type SqliteDatabase } from "sqlite-wasm-kysely";
+import { v7 } from "uuid";
+import { humanId } from "../human-id/human-id.js";
+import { JsonbPlugin } from "./jsonbPlugin.js";
+
+export function initDb(args: { sqlite: SqliteDatabase }) {
+	initDefaultValueFunctions({ sqlite: args.sqlite });
+	applySchema({ sqlite: args.sqlite });
+	const db = new Kysely<InlangDatabaseSchema>({
+		dialect: createDialect({
+			database: args.sqlite,
+		}),
+		plugins: [
+			new CamelCasePlugin(),
+			new JsonbPlugin({ database: args.sqlite }),
+		],
+	});
+	return db;
+}
+
+function initDefaultValueFunctions(args: { sqlite: SqliteDatabase }) {
+	args.sqlite.createFunction({
+		name: "uuid_v7",
+		arity: 0,
+		xFunc: () => v7(),
+	});
+	args.sqlite.createFunction({
+		name: "human_id",
+		arity: 0,
+		xFunc: () => humanId(),
+	});
+}

package/src/database/initDbAndSchema.test.ts

@@ -0,0 +1,125 @@
+import { createInMemoryDatabase } from "sqlite-wasm-kysely";
+import { test, expect } from "vitest";
+import { initDb } from "./initDb.js";
+import { isHumanId } from "../human-id/human-id.js";
+import { validate as isUuid } from "uuid";
+
+test("bundle default values", async () => {
+	const sqlite = await createInMemoryDatabase({
+		readOnly: false,
+	});
+	const db = initDb({ sqlite });
+
+	const bundle = await db
+		.insertInto("bundle")
+		.defaultValues()
+		.returningAll()
+		.executeTakeFirstOrThrow();
+
+	expect(isHumanId(bundle.id)).toBe(true);
+	expect(bundle.declarations).toStrictEqual([]);
+});
+
+test("message default values", async () => {
+	const sqlite = await createInMemoryDatabase({
+		readOnly: false,
+	});
+	const db = initDb({ sqlite });
+
+	const bundle = await db
+		.insertInto("bundle")
+		.defaultValues()
+		.returningAll()
+		.executeTakeFirstOrThrow();
+
+	const message = await db
+		.insertInto("message")
+		.values({
+			bundleId: bundle.id,
+			locale: "en",
+		})
+		.returningAll()
+		.executeTakeFirstOrThrow();
+
+	expect(isUuid(message.id)).toBe(true);
+	expect(message.selectors).toStrictEqual([]);
+});
+
+test("variant default values", async () => {
+	const sqlite = await createInMemoryDatabase({
+		readOnly: false,
+	});
+	const db = initDb({ sqlite });
+
+	const bundle = await db
+		.insertInto("bundle")
+		.defaultValues()
+		.returningAll()
+		.executeTakeFirstOrThrow();
+
+	const message = await db
+		.insertInto("message")
+		.values({
+			bundleId: bundle.id,
+			locale: "en",
+		})
+		.returningAll()
+		.executeTakeFirstOrThrow();
+
+	const variant = await db
+		.insertInto("variant")
+		.values({
+			messageId: message.id,
+		})
+		.returningAll()
+		.executeTakeFirstOrThrow();
+
+	expect(isUuid(variant.id)).toBe(true);
+	expect(variant.matches).toStrictEqual([]);
+	expect(variant.pattern).toStrictEqual([]);
+});
+
+test("it should handle json serialization and parsing for bundles", async () => {
+	const sqlite = await createInMemoryDatabase({
+		readOnly: false,
+	});
+	const db = initDb({ sqlite });
+
+	const bundle = await db
+		.insertInto("bundle")
+		.values({
+			declarations: [
+				{
+					type: "input-variable",
+					name: "mock",
+				},
+			],
+		})
+		.returningAll()
+		.executeTakeFirstOrThrow();
+
+	expect(bundle.declarations).toStrictEqual([
+		{
+			type: "input-variable",
+			name: "mock",
+		},
+	]);
+});
+
+// https://github.com/opral/inlang-sdk/issues/209
+test.todo("it should enable foreign key constraints", async () => {
+	const sqlite = await createInMemoryDatabase({
+		readOnly: false,
+	});
+	const db = initDb({ sqlite });
+
+	expect(() =>
+		db
+			.insertInto("message")
+			.values({
+				bundleId: "non-existent",
+				locale: "en",
+			})
+			.execute()
+	).rejects.toThrow();
+});

package/src/database/jsonbPlugin.test.ts

@@ -0,0 +1,154 @@
+import { Kysely } from "kysely";
+import { createDialect, createInMemoryDatabase } from "sqlite-wasm-kysely";
+import { test, expect } from "vitest";
+import { JsonbPlugin } from "./jsonbPlugin.js";
+
+test("parsing and serializing of jsonb should work", async () => {
+	type MockSchema = {
+		foo: {
+			id: string;
+			data: Record<string, any>;
+		};
+	};
+	const database = await createInMemoryDatabase({
+		readOnly: false,
+	});
+
+	database.exec(`
+    CREATE TABLE foo (
+      id TEXT PRIMARY KEY,
+      data BLOB NOT NULL
+    ) strict;  
+  `);
+
+	const db = new Kysely<MockSchema>({
+		dialect: createDialect({
+			database,
+		}),
+		plugins: [new JsonbPlugin({ database })],
+	});
+
+	const foo = await db
+		.insertInto("foo")
+		.values({
+			id: "mock",
+			data: {
+				data: "baz",
+			},
+		})
+		.returningAll()
+		.executeTakeFirstOrThrow();
+
+	expect(foo).toEqual({
+		id: "mock",
+		data: {
+			data: "baz",
+		},
+	});
+});
+
+test("upserts should be handled", async () => {
+	type MockSchema = {
+		foo: {
+			id: string;
+			data: Record<string, any>;
+		};
+	};
+	const database = await createInMemoryDatabase({
+		readOnly: false,
+	});
+
+	database.exec(`
+    CREATE TABLE foo (
+      id TEXT PRIMARY KEY,
+      data BLOB NOT NULL
+    ) strict;  
+  `);
+
+	const db = new Kysely<MockSchema>({
+		dialect: createDialect({
+			database,
+		}),
+		plugins: [
+			new JsonbPlugin({
+				database,
+			}),
+		],
+	});
+
+	const foo = await db
+		.insertInto("foo")
+		.values({
+			id: "mock",
+			data: {
+				bar: "baz",
+			},
+		})
+		.returningAll()
+		.executeTakeFirstOrThrow();
+
+	expect(foo).toEqual({
+		id: "mock",
+		data: {
+			bar: "baz",
+		},
+	});
+
+	const updatedFoo = {
+		id: "mock",
+		data: {
+			bar: "baz",
+			baz: "qux",
+		},
+	};
+
+	const updatedFooResult = await db
+		.insertInto("foo")
+		.values(updatedFoo)
+		.returningAll()
+		.onConflict((oc) => oc.column("id").doUpdateSet(updatedFoo))
+		.executeTakeFirstOrThrow();
+
+	expect(updatedFooResult).toEqual(updatedFoo);
+});
+
+test("storing json as text is supposed to fail to avoid heuristics if the json should be stored as blob or text", async () => {
+	type MockSchema = {
+		foo: {
+			id: string;
+			data: Record<string, any>;
+		};
+	};
+	const database = await createInMemoryDatabase({
+		readOnly: false,
+	});
+
+	database.exec(`
+    CREATE TABLE foo (
+      id TEXT PRIMARY KEY,
+      data TEXT NOT NULL
+    ) strict;  
+  `);
+
+	const db = new Kysely<MockSchema>({
+		dialect: createDialect({
+			database,
+		}),
+		plugins: [new JsonbPlugin({ database })],
+	});
+
+	expect(() =>
+		db
+			.insertInto("foo")
+			.values({
+				id: "mock",
+				data: {
+					bar: "baz",
+				},
+			})
+			.returningAll()
+			.executeTakeFirstOrThrow()
+	).rejects.toThrowErrorMatchingInlineSnapshot(
+		`[SQLite3Error: SQLITE_CONSTRAINT_DATATYPE: sqlite3 result code 3091: cannot store BLOB value in TEXT column foo.data]`
+	);
+});

package/src/database/jsonbPlugin.ts

@@ -0,0 +1,215 @@
+import {
+	OperationNodeTransformer,
+	sql,
+	ValueListNode,
+	ValueNode,
+	ValuesNode,
+	ParseJSONResultsPlugin,
+	type KyselyPlugin,
+	type PluginTransformQueryArgs,
+	type PluginTransformResultArgs,
+	type QueryResult,
+	type RootOperationNode,
+	type UnknownRow,
+	OnConflictNode,
+} from "kysely";
+import type { SqliteDatabase } from "sqlite-wasm-kysely";
+
+export class JsonbPlugin implements KyselyPlugin {
+	#serializeJsonTransformer = new SerializeJsonbTransformer();
+	#parseJsonPlugin = new ParseJSONResultsPlugin();
+	#database: SqliteDatabase;
+
+	constructor(args: { database: SqliteDatabase }) {
+		this.#database = args.database;
+	}
+
+	/**
+	 * For an outgoing query like insert or update, the JSON
+	 * values are transformed into `jsonb` function calls when
+	 * executed against the database.
+	 */
+	transformQuery(args: PluginTransformQueryArgs): RootOperationNode {
+		if (
+			args.node.kind === "InsertQueryNode" ||
+			args.node.kind === "UpdateQueryNode"
+		) {
+			const result = this.#serializeJsonTransformer.transformNode(args.node);
+			return result;
+		}
+		return args.node;
+	}
+
+	/**
+	 * For incoming query results, the JSON binaries are parsed
+	 * into JSON objects.
+	 */
+	async transformResult(
+		args: PluginTransformResultArgs
+	): Promise<QueryResult<UnknownRow>> {
+		for (const row of args.result.rows) {
+			for (const key in row) {
+				if (
+					row[key] instanceof ArrayBuffer ||
+					// uint8array, etc
+					ArrayBuffer.isView(row[key])
+				) {
+					try {
+						const res = this.#database.exec(`SELECT json(?)`, {
+							returnValue: "resultRows",
+							bind: [row[key] as any],
+						});
+
+						row[key] = JSON.parse(res[0] as any);
+					} catch {
+						// it's not a json binary
+					}
+				}
+			}
+		}
+		// in case it's a regular (text) json, run it through kyseley's json parser
+		return this.#parseJsonPlugin.transformResult(args);
+	}
+}
+
+class SerializeJsonbTransformer extends OperationNodeTransformer {
+	protected override transformOnConflict(node: OnConflictNode): OnConflictNode {
+		return super.transformOnConflict({
+			...node,
+			updates: node.updates?.map((updateItem) => {
+				if (updateItem.kind !== "ColumnUpdateNode") {
+					return updateItem;
+				}
+				return {
+					kind: "ColumnUpdateNode",
+					column: updateItem.column,
+					// @ts-expect-error - we know that the value is a ValueNode
+					value: this.transformValue(updateItem.value),
+				};
+			}),
+		});
+	}
+
+	protected override transformValue(node: ValueNode): ValueNode {
+		const { value } = node;
+		const serializedValue = maybeSerializeJson(value);
+		if (value === serializedValue) {
+			return node;
+		}
+		// @ts-expect-error - we know that the node is a ValueNode
+		return sql`jsonb(${serializedValue})`.toOperationNode();
+	}
+	/**
+	 * Transforms the value list node by replacing all JSON objects with `jsonb` function calls.
+	 */
+	protected override transformValueList(node: ValueListNode): ValueListNode {
+		return super.transformValueList({
+			...node,
+			values: node.values.map((listNodeItem) => {
+				if (listNodeItem.kind !== "ValueNode") {
+					return listNodeItem;
+				}
+				// @ts-expect-error - we know that the node is a ValueNode
+				const { value } = listNodeItem;
+				const serializedValue = maybeSerializeJson(value);
+
+				if (value === serializedValue) {
+					return listNodeItem;
+				}
+				return sql`jsonb(${serializedValue})`.toOperationNode();
+			}),
+		});
+	}
+
+	/**
+	 * Why this function is needed or why this works remains a mystery.
+	 */
+	override transformValues(node: ValuesNode): ValuesNode {
+		return super.transformValues({
+			...node,
+			values: node.values.map((valueItemNode) => {
+				if (valueItemNode.kind !== "PrimitiveValueListNode") {
+					return valueItemNode;
+				}
+
+				// change valueItem to ValueListNode
+				return {
+					kind: "ValueListNode",
+					values: valueItemNode.values.map(
+						(value) =>
+							({
+								kind: "ValueNode",
+								value,
+							}) as ValueNode
+					),
+				} as ValueListNode;
+			}),
+		});
+	}
+}
+
+function maybeSerializeJson(value: any): any {
+	if (
+		// binary data
+		value instanceof ArrayBuffer ||
+		// uint8array, etc
+		ArrayBuffer.isView(value) ||
+		value === null ||
+		value === undefined
+	) {
+		return value;
+	} else if (typeof value === "object" || Array.isArray(value)) {
+		return JSON.stringify(value);
+	}
+	return value;
+}
+
+// The code here didn't work https://github.com/opral/inlang-sdk/issues/132#issuecomment-2339321910
+// but would be the "right" solution to avoid heuristics which column might or might not be a json column
+// // modifies the query in place for readability and performance
+// function mapQuery(
+// 	node: InsertQueryNode,
+// 	jsonColumns: TableSchema
+// ): InsertQueryNode {
+// 	// if the query is not an insert query, we don't need to do anything
+// 	if (node.into === undefined) {
+// 		return node;
+// 	}
+// 	// if the table is not in the schema that has json columns, we don't need to do anything
+// 	const columnsWithJson = jsonColumns[node.into.table.identifier.name];
+// 	if (columnsWithJson === undefined) {
+// 		return node;
+// 	}
+// 	// find the indexes of the values that need to be transformed
+// 	// SQL query: INSERT INTO table (col1, col2) VALUES (val1, val2)
+// 	const indexesThatNeedToBeTransformed: [number, string][] = [];
+// 	for (const [i, col] of node.columns?.entries() ?? []) {
+// 		const jsonType = columnsWithJson[col.column.name];
+// 		if (jsonType !== undefined) {
+// 			indexesThatNeedToBeTransformed.push([i, jsonType]);
+// 		}
+// 	}
+// 	const values = structuredClone(node.values);
+// 	for (const [i, jsonType] of indexesThatNeedToBeTransformed) {
+// 		if (
+// 			// top level values node that should contain a list of values
+// 			node.values?.kind !== "ValuesNode" &&
+// 			// the node we are interested in must be a value node
+// 			// @ts-expect-error - we know that the node is a ValuesNode with values
+// 			(node.values as ValuesNode).values?.[i].kind !== "ValueNode"
+// 		) {
+// 			throw new Error("Unexpected node structure");
+// 		}
+// 		const serializedJson = JSON.stringify(node.values.values[0].values[i]);
+// 		// @ts-expect-error - we know that the node is a ValuesNode with values
+// 		values.values[0].values[i] =
+// 			jsonType === "jsonb"
+// 				? sql`jsonb(${serializedJson})`.toOperationNode()
+// 				: sql`json(${serializedJson})`.toOperationNode();
+// 	}
+
+// 	return {
+// 		...node,
+// 		values,
+// 	};
+// }