@inlang/sdk 0.36.3 → 2.0.0-prerelease.0

package/node_modules/@lix-js/sdk/src/database/schema.ts

@@ -0,0 +1,273 @@
+import type { Generated, Insertable, Selectable, Updateable } from "kysely";
+import type {
+	AccountTable,
+	ActiveAccountTable,
+} from "../account/database-schema.js";
+import type { KeyValueTable } from "../key-value/database-schema.js";
+import type { MutationLogTable } from "./mutation-log/database-schema.js";
+
+export type LixDatabaseSchema = {
+	// account
+	account: AccountTable;
+	active_account: ActiveAccountTable;
+
+	// snapshot
+	snapshot: SnapshotTable;
+	label: LabelTable;
+
+	// file
+	file: LixFileTable;
+	file_queue: FileQueueTable;
+
+	// change
+	change: ChangeTable;
+	change_edge: ChangeEdgeTable;
+	change_author: ChangeAuthorTable;
+
+	// change set
+	change_set: ChangeSetTable;
+	change_set_element: ChangeSetElementTable;
+	change_set_label: ChangeSetLabelTable;
+
+	// key value
+	key_value: KeyValueTable;
+
+	// discussion
+	discussion: DiscussionTable;
+	comment: CommentTable;
+
+	// version
+	current_version: CurrentVersionTable;
+	version: VersionTable;
+	version_change: VersionChangeTable;
+	version_change_conflict: VersionChangeConflictTable;
+
+	// change conflicts
+	change_conflict: ChangeConflictTable;
+	change_conflict_resolution: ChangeConflictResolutionTable;
+
+	mutation_log: MutationLogTable;
+};
+
+export type FileQueueEntry = Selectable<FileQueueTable>;
+export type NewFileQueueEntry = Insertable<FileQueueTable>;
+export type FileQueueEntryUpdate = Updateable<FileQueueTable>;
+type FileQueueTable = {
+	id: Generated<number>;
+	file_id: string;
+	path_before: string | null;
+	path_after: string | null;
+	data_before: Uint8Array | null;
+	data_after: Uint8Array | null;
+	metadata_before: Record<string, any> | null;
+	metadata_after: Record<string, any> | null;
+};
+
+// named lix file to avoid conflict with built-in file type
+export type LixFile = Selectable<LixFileTable>;
+export type NewLixFile = Insertable<LixFileTable>;
+export type LixFileUpdate = Updateable<LixFileTable>;
+type LixFileTable = {
+	id: Generated<string>;
+	/**
+	 * The path of the file.
+	 *
+	 * The path is currently defined as a subset of RFC 3986.
+	 * Any path can be tested with the `isValidFilePath()` function.
+	 *
+	 * @example
+	 *   - `/path/to/file.txt`
+	 */
+	path: string;
+	data: Uint8Array;
+	metadata: Record<string, any> | null;
+};
+
+export type Change = Selectable<ChangeTable>;
+export type NewChange = Insertable<ChangeTable>;
+type ChangeTable = {
+	id: Generated<string>;
+	/**
+	 * The entity the change refers to.
+	 */
+	entity_id: string;
+	file_id: string;
+	/**
+	 * The plugin key that contributed the change.
+	 *
+	 * Exists to ease querying for changes by plugin,
+	 * in case the user changes the plugin configuration.
+	 */
+	plugin_key: string;
+	/**
+	 * The schema key that the change refers to.
+	 */
+	schema_key: string;
+	snapshot_id: string;
+	/**
+	 * The time the change was created.
+	 */
+	created_at: Generated<string>;
+};
+
+export type ChangeEdge = Selectable<ChangeEdgeTable>;
+export type NewChangeEdge = Insertable<ChangeEdgeTable>;
+type ChangeEdgeTable = {
+	parent_id: string;
+	child_id: string;
+};
+
+export type ChangeAuthor = Selectable<ChangeAuthorTable>;
+export type NewChangeAuthor = Insertable<ChangeAuthorTable>;
+type ChangeAuthorTable = {
+	change_id: string;
+	account_id: string;
+};
+
+export type Snapshot = Selectable<SnapshotTable>;
+export type NewSnapshot = Insertable<SnapshotTable>;
+type SnapshotTable = {
+	id: Generated<string>;
+	/**
+	 * The value of the change.
+	 *
+	 * Lix interprets an undefined value as delete operation.
+	 *
+	 * @example
+	 *   - For a csv cell change, the value would be the new cell value.
+	 *   - For an inlang message change, the value would be the new message.
+	 */
+	content: Record<string, any> | null;
+};
+
+// ------ change sets ------
+
+export type ChangeSet = Selectable<ChangeSetTable>;
+export type NewChangeSet = Insertable<ChangeSetTable>;
+export type ChangeSetUpdate = Updateable<ChangeSetTable>;
+type ChangeSetTable = {
+	id: Generated<string>;
+};
+
+export type ChangeSetElement = Selectable<ChangeSetElementTable>;
+export type NewChangeSetElement = Insertable<ChangeSetElementTable>;
+export type ChangeSetElementUpdate = Updateable<ChangeSetElementTable>;
+type ChangeSetElementTable = {
+	change_set_id: string;
+	change_id: string;
+};
+
+// ------ discussions ------
+
+export type Discussion = Selectable<DiscussionTable>;
+export type NewDiscussion = Insertable<DiscussionTable>;
+export type DiscussionUpdate = Updateable<DiscussionTable>;
+type DiscussionTable = {
+	id: Generated<string>;
+	change_set_id: string;
+};
+
+export type Comment = Selectable<CommentTable>;
+export type NewComment = Insertable<CommentTable>;
+export type CommentUpdate = Updateable<CommentTable>;
+type CommentTable = {
+	id: Generated<string>;
+	parent_id: string | null;
+	discussion_id: string;
+	content: string;
+};
+
+// ----- tags -----
+
+export type Label = Selectable<LabelTable>;
+export type NewLabel = Insertable<LabelTable>;
+export type LabelUpdate = Updateable<LabelTable>;
+type LabelTable = {
+	id: Generated<string>;
+	name: string;
+};
+
+export type ChangeSetLabel = Selectable<ChangeSetLabelTable>;
+export type NewChangeSetLabel = Insertable<ChangeSetLabelTable>;
+export type ChangeSetLabelUpdate = Updateable<ChangeSetLabelTable>;
+type ChangeSetLabelTable = {
+	change_set_id: string;
+	label_id: string;
+};
+
+// ------ versiones ------
+
+export type Version = Selectable<VersionTable>;
+export type Newversion = Insertable<VersionTable>;
+export type VersionUpdate = Updateable<VersionTable>;
+type VersionTable = {
+	id: Generated<string>;
+	name: Generated<string>;
+};
+
+export type VersionChange = Selectable<VersionChangeTable>;
+export type NewVersionChange = Insertable<VersionChangeTable>;
+export type VersionChangeUpdate = Updateable<VersionChangeTable>;
+type VersionChangeTable = {
+	version_id: string;
+	change_id: string;
+	entity_id: string;
+	file_id: string;
+	schema_key: string;
+};
+
+export type VersionChangeConflict = Selectable<VersionChangeConflictTable>;
+export type NewversionChangeConflict = Insertable<VersionChangeConflictTable>;
+export type VersionChangeConflictUpdate =
+	Updateable<VersionChangeConflictTable>;
+type VersionChangeConflictTable = {
+	version_id: string;
+	change_conflict_id: string;
+};
+
+export type CurrentVersion = Selectable<CurrentVersionTable>;
+export type NewCurrentVersion = Insertable<CurrentVersionTable>;
+export type CurrentVersionUpdate = Updateable<CurrentVersionTable>;
+type CurrentVersionTable = {
+	id: string;
+};
+
+// export type versionTarget = Selectable<versionTargetTable>;
+// export type NewversionTarget = Insertable<versionTargetTable>;
+// export type versionTargetUpdate = Updateable<versionTargetTable>;
+// type versionTargetTable = {
+// 	source_version_id: string;
+// 	target_version_id: string;
+// };
+
+// -------- change conflicts --------
+
+export type ChangeConflict = Selectable<ChangeConflictTable>;
+export type NewChangeConflict = Insertable<ChangeConflictTable>;
+export type ChangeConflictUpdate = Updateable<ChangeConflictTable>;
+type ChangeConflictTable = {
+	id: Generated<string>;
+	/**
+	 * The key is used to identify the conflict.
+	 *
+	 * The key should be unique for the plugin and the conflict
+	 * to avoid duplicate conflict reports.
+	 *
+	 * @example
+	 *   - `csv-row-order-changed`
+	 *   - `inlang-message-bundle-foreign-key-violation`
+	 */
+	key: string;
+	change_set_id: string;
+};
+
+export type ChangeConflictResolution =
+	Selectable<ChangeConflictResolutionTable>;
+export type NewChangeConflictResolution =
+	Insertable<ChangeConflictResolutionTable>;
+export type ChangeConflictResolutionUpdate =
+	Updateable<ChangeConflictResolutionTable>;
+type ChangeConflictResolutionTable = {
+	change_conflict_id: string;
+	resolved_change_id: string;
+};

package/node_modules/@lix-js/sdk/src/discussion/create-comment.ts

@@ -0,0 +1,18 @@
+import type { Comment } from "../database/schema.js";
+import type { Lix } from "../lix/open-lix.js";
+
+export async function createComment(args: {
+	lix: Pick<Lix, "db">;
+	parentComment: Pick<Comment, "id" | "discussion_id">;
+	content: string;
+}): Promise<Comment> {
+	return args.lix.db
+		.insertInto("comment")
+		.values({
+			discussion_id: args.parentComment.discussion_id,
+			parent_id: args.parentComment.id,
+			content: args.content,
+		})
+		.returningAll()
+		.executeTakeFirstOrThrow();
+}

package/node_modules/@lix-js/sdk/src/discussion/create-discussion.test.ts

@@ -0,0 +1,45 @@
+import { expect, test } from "vitest";
+import { openLixInMemory } from "../lix/open-lix-in-memory.js";
+import { createDiscussion } from "./create-discussion.js";
+import { createChangeSet } from "../change-set/create-change-set.js";
+
+test("should be able to start a discussion on changes", async () => {
+	const lix = await openLixInMemory({});
+
+	// produce a change
+	await lix.db
+		.insertInto("key_value")
+		.values({
+			key: "mock_key",
+			value: "mock_value",
+		})
+		.execute();
+
+	const changes = await lix.db
+		.selectFrom("change")
+		.selectAll("change")
+		.execute();
+
+	await lix.db.transaction().execute(async (trx) => {
+		await createDiscussion({
+			lix: { db: trx },
+			firstComment: { content: "Hello, world!" },
+			changeSet: await createChangeSet({ lix: { db: trx }, changes }),
+		});
+	});
+
+	const discussions = await lix.db
+		.selectFrom("discussion")
+		.selectAll()
+		.execute();
+
+	expect(discussions).toHaveLength(1);
+
+	const comments = await lix.db
+		.selectFrom("comment")
+		.selectAll()
+		.where("discussion_id", "=", discussions[0]!.id)
+		.execute();
+
+	expect(comments).toHaveLength(1);
+});

package/node_modules/@lix-js/sdk/src/discussion/create-discussion.ts

@@ -0,0 +1,48 @@
+import type { ChangeSet, Comment, Discussion } from "../database/schema.js";
+import type { Lix } from "../lix/open-lix.js";
+
+/**
+ * Creates a new discussion with the first comment.
+ *
+ * @example
+ *   ```ts
+ *   const changeSet = await createChangeSet({ lix, changes: ["change1", "change2"] });
+ *   const discussion = await createDiscussion({ lix, changeSet, firstComment: { content: "first comment" } });
+ *   ```
+ *
+ * @returns the created discussion
+ */
+export async function createDiscussion(args: {
+	lix: Pick<Lix, "db">;
+	changeSet: Pick<ChangeSet, "id">;
+	firstComment: Pick<Comment, "content">;
+}): Promise<Discussion & { firstComment: Comment }> {
+	const executeInTransaction = async (trx: Lix["db"]) => {
+		const discussion = await trx
+			.insertInto("discussion")
+			.values({
+				change_set_id: args.changeSet.id,
+			})
+			.returningAll()
+			.executeTakeFirstOrThrow();
+
+		const firstComment = await trx
+			.insertInto("comment")
+			.values({
+				parent_id: null,
+				discussion_id: discussion.id,
+				content: args.firstComment.content,
+			})
+			.returningAll()
+			.executeTakeFirstOrThrow();
+
+		return { ...discussion, firstComment };
+	};
+
+	// user provided an open transaction
+	if (args.lix.db.isTransaction) {
+		return executeInTransaction(args.lix.db);
+	} else {
+		return args.lix.db.transaction().execute(executeInTransaction);
+	}
+}

package/node_modules/@lix-js/sdk/src/discussion/index.ts

@@ -0,0 +1,2 @@
+export { createDiscussion } from "./create-discussion.js";
+export { createComment } from "./create-comment.js";

package/node_modules/@lix-js/sdk/src/file/index.ts

@@ -0,0 +1 @@
+export { validateFilePath, isValidFilePath } from "./validate-file-path.js";

package/node_modules/@lix-js/sdk/src/file/validate-file-path.test.ts

@@ -0,0 +1,44 @@
+import { test, expect } from "vitest";
+import { isValidFilePath } from "./validate-file-path.js";
+
+test("valid cases", () => {
+	const validCases = [
+		"/path/to/file",
+		"/path/to/file/with/multiple/segments",
+		"/path/to/file.with.dots",
+		"/path/to/file-with-hyphens_and_underscores",
+		"/path/with-file-extension.txt",
+	];
+
+	for (const validCase of validCases) {
+		expect(isValidFilePath(validCase)).toBe(true);
+		// testing for RFC 3986 URI
+		expect(URL.canParse(`file://${validCase}`)).toBe(true);
+	}
+});
+
+// invalid cases
+
+test("an empty path should be invalid", () => {
+	expect(isValidFilePath("")).toBe(false);
+});
+
+test("a path that contains only a slash should be invalid", () => {
+	expect(isValidFilePath("/")).toBe(false);
+});
+
+test("a path that does not start with a slash should be invalid", () => {
+	expect(isValidFilePath("path/to/file")).toBe(false);
+});
+
+test("a path that ends with a slash should be invalid", () => {
+	expect(isValidFilePath("/path/to/file/")).toBe(false);
+});
+
+test("a path that contains consecutive slashes should be invalid", () => {
+	expect(isValidFilePath("/path//to/file")).toBe(false);
+});
+
+test("a path that contains backslashes should be invalid", () => {
+	expect(isValidFilePath("/path\\to\\file")).toBe(false);
+});

package/node_modules/@lix-js/sdk/src/file/validate-file-path.ts

@@ -0,0 +1,60 @@
+/**
+ * Idea is to have a minimal spec that can be extended over time.
+ *
+ * Every valid file path must also be a valid RFC 3986 URI.
+ */
+
+/**
+ * Validates a file path.
+ *
+ * @throws {Error} If the file path is invalid.
+ */
+export function validateFilePath(path: string): void {
+	// validate beginning
+
+	if (path.length === 0) {
+		throw new Error("File path must not be empty.");
+	}
+
+	if (path[0] !== "/") {
+		throw new Error(
+			"File path must start with a slash.\n\nNot starting a file path with a slash `/` leads to ambiguity whether or not the path is a directory or a file."
+		);
+	}
+
+	// validate middle
+
+	// validate ending
+
+	if (path.endsWith("/")) {
+		throw new Error(
+			"File path must not end with a slash.\n\nEnding a file with a slash leads to ambiguity whether or not the path is a directory or a file."
+		);
+	}
+
+	// validate general
+
+	if (path.includes("//")) {
+		throw new Error(
+			"File path must not contain consecutive slashes.\n\nConsecutive slashes lead to ambiguity whether or not the path is a directory or a file."
+		);
+	}
+
+	if (path.includes("\\")) {
+		throw new Error(
+			"File path must not contain backslashes.\n\nThe restriction might be loosened in the future."
+		);
+	}
+}
+
+/**
+ *
+ */
+export function isValidFilePath(path: string): boolean {
+	try {
+		validateFilePath(path);
+		return true;
+	} catch {
+		return false;
+	}
+}