@nkzw/codiff-service 1.9.0

package/dist/index.mjs

@@ -0,0 +1,6 @@
+import { plan, planRelations, shareCommentMessage, shareCommentMessageRelations, shareCommentThread, shareCommentThreadKind, shareCommentThreadRelations, shareCommentThreadStatus, shareDailyUsage, shareDailyUsageRelations, shareKind, uploadIntent, user, userRelations, walkthrough, walkthroughFile, walkthroughFileRelations, walkthroughRelations } from "./schema.mjs";
+import { and, createDb, db, eq, gte, runDatabaseBatches, sql, withDatabase } from "./db.mjs";
+import { getAuthenticatedShareUser, getRepositoryMetadata, handleSharingApiRequest, parseGitPullRequestUrl, parseShareUpload, shareUserFromAuthValue } from "./api.mjs";
+import { SharingRoot, getSessionUserId, planDataView, shareCommentMessageDataView, shareCommentThreadDataView, shareStatsDataView, shareStatsDayDataView, uploadIntentDataView, uploadIntentSecretHeader, walkthroughDataView } from "./views.mjs";
+import { createSharingFateServer, shareCommentAnchorSchema, shareCommentTargetSchema } from "./fate.mjs";
+export { SharingRoot, and, createDb, createSharingFateServer, db, eq, getAuthenticatedShareUser, getRepositoryMetadata, getSessionUserId, gte, handleSharingApiRequest, parseGitPullRequestUrl, parseShareUpload, plan, planDataView, planRelations, runDatabaseBatches, shareCommentAnchorSchema, shareCommentMessage, shareCommentMessageDataView, shareCommentMessageRelations, shareCommentTargetSchema, shareCommentThread, shareCommentThreadDataView, shareCommentThreadKind, shareCommentThreadRelations, shareCommentThreadStatus, shareDailyUsage, shareDailyUsageRelations, shareKind, shareStatsDataView, shareStatsDayDataView, shareUserFromAuthValue, sql, uploadIntent, uploadIntentDataView, uploadIntentSecretHeader, user, userRelations, walkthrough, walkthroughDataView, walkthroughFile, walkthroughFileRelations, walkthroughRelations, withDatabase };

package/dist/react.mjs

@@ -0,0 +1,62 @@
+import { PlanReviewSurface, ReviewSurface } from "@nkzw/codiff-core/react";
+import { jsx } from "react/jsx-runtime";
+//#region react.tsx
+const asRecord = (value) => value && typeof value === "object" ? value : null;
+const submittedShareCommentMessage = (value) => {
+	const message = asRecord(value);
+	if (!message || typeof message.authorName !== "string" || typeof message.body !== "string" || typeof message.canEdit !== "boolean" || typeof message.createdAt !== "string" || typeof message.id !== "string" || typeof message.threadId !== "string") throw new Error("Unable to load the submitted walkthrough comment.");
+	return {
+		authorImage: typeof message.authorImage === "string" ? message.authorImage : null,
+		authorName: message.authorName,
+		authorUsername: typeof message.authorUsername === "string" ? message.authorUsername : null,
+		body: message.body,
+		canEdit: message.canEdit,
+		createdAt: message.createdAt,
+		id: message.id,
+		threadId: message.threadId
+	};
+};
+const toSubmittedReviewComment = (comment, message, threadId, canResolveThread) => ({
+	...comment,
+	author: {
+		...message.authorImage ? { avatarUrl: message.authorImage } : {},
+		login: message.authorUsername ?? message.authorName,
+		name: message.authorName
+	},
+	body: message.body,
+	...message.canEdit ? {
+		canDelete: true,
+		canEdit: true
+	} : {},
+	...canResolveThread ? { canResolveThread: true } : {},
+	id: message.id,
+	submittedAt: message.createdAt,
+	threadId
+});
+const resolveSubmittedShareReply = ({ canResolveThread, comment, result }) => toSubmittedReviewComment(comment, submittedShareCommentMessage(result), comment.threadId, canResolveThread);
+const resolveSubmittedShareThread = ({ canResolveThread, comment, result }) => {
+	const thread = asRecord(result);
+	const messages = thread ? asRecord(thread.messages) : null;
+	const firstItem = messages && Array.isArray(messages.items) ? asRecord(messages.items[0]) : null;
+	if (!thread || typeof thread.id !== "string" || !firstItem) throw new Error("Unable to load the submitted walkthrough comment.");
+	return toSubmittedReviewComment(comment, submittedShareCommentMessage(firstItem.node), thread.id, canResolveThread);
+};
+function SharedPlanApp({ providerLabel, ...props }) {
+	return /* @__PURE__ */ jsx(PlanReviewSurface, {
+		...props,
+		signInLabel: `Sign in with ${providerLabel} to comment`
+	});
+}
+function SharedWalkthroughApp({ commenting, gitIdentity, onDeleteShare, providerLabel, settingsBar, snapshot }) {
+	return /* @__PURE__ */ jsx(ReviewSurface, {
+		commenting,
+		gitIdentity,
+		onDeleteShare,
+		providerLabel,
+		settingsBar,
+		signInLabel: `Sign in with ${providerLabel} to comment`,
+		snapshot
+	});
+}
+//#endregion
+export { SharedPlanApp, SharedWalkthroughApp, resolveSubmittedShareReply, resolveSubmittedShareThread };

package/dist/schema.mjs

@@ -0,0 +1,219 @@
+import { relations, sql } from "drizzle-orm";
+import { check, index, integer, primaryKey, sqliteTable, text, uniqueIndex } from "drizzle-orm/sqlite-core";
+//#region schema.ts
+const idColumn = () => text().notNull().$defaultFn(() => crypto.randomUUID());
+const timestampColumn = () => integer({ mode: "timestamp" }).notNull().default(sql`(unixepoch())`);
+const nullableTimestampColumn = () => integer({ mode: "timestamp" });
+const shareCommentThreadKind = [
+	"plan",
+	"walkthrough-diff",
+	"walkthrough-general"
+];
+const shareCommentThreadStatus = ["open", "resolved"];
+const shareKind = ["plan", "walkthrough"];
+const user = sqliteTable("user", {
+	banExpires: nullableTimestampColumn(),
+	banned: integer({ mode: "boolean" }),
+	banReason: text(),
+	createdAt: timestampColumn(),
+	displayUsername: text(),
+	email: text().notNull(),
+	emailVerified: integer({ mode: "boolean" }).notNull().default(false),
+	id: idColumn().primaryKey(),
+	image: text(),
+	name: text().notNull(),
+	password: text(),
+	role: text().notNull().default("user"),
+	updatedAt: timestampColumn(),
+	username: text()
+}, (table) => [
+	uniqueIndex("user_email_key").on(table.email),
+	uniqueIndex("user_username_key").on(table.username),
+	index("user_id_idx").on(table.id)
+]);
+const walkthrough = sqliteTable("Walkthrough", {
+	branch: text(),
+	byteSize: integer().notNull(),
+	codiffVersion: text().notNull(),
+	commentsImportedAt: nullableTimestampColumn(),
+	createdAt: timestampColumn(),
+	description: text(),
+	filesIndexedAt: nullableTimestampColumn(),
+	id: idColumn().primaryKey(),
+	objectKey: text().notNull(),
+	pullRequestNumber: integer(),
+	pullRequestTitle: text(),
+	pullRequestUrl: text(),
+	repositoryHost: text(),
+	repositoryName: text(),
+	repositoryOwner: text(),
+	repositoryUrl: text(),
+	schemaVersion: integer().notNull(),
+	sha256: text().notNull(),
+	sharedByEmail: text(),
+	sharedByName: text(),
+	sharedByUserId: text().references(() => user.id, { onDelete: "set null" }),
+	slug: text().notNull(),
+	sourceType: text().notNull(),
+	title: text().notNull(),
+	updatedAt: timestampColumn()
+}, (table) => [
+	uniqueIndex("Walkthrough_slug_key").on(table.slug),
+	index("Walkthrough_sharedByEmail_idx").on(table.sharedByEmail),
+	index("Walkthrough_sharedByUserId_idx").on(table.sharedByUserId),
+	index("Walkthrough_repository_idx").on(table.repositoryOwner, table.repositoryName)
+]);
+const walkthroughFile = sqliteTable("WalkthroughFile", {
+	path: text().notNull(),
+	walkthroughId: text().notNull().references(() => walkthrough.id, { onDelete: "cascade" })
+}, (table) => [primaryKey({
+	columns: [table.walkthroughId, table.path],
+	name: "WalkthroughFile_walkthroughId_path_pkey"
+})]);
+const plan = sqliteTable("Plan", {
+	agent: text(),
+	byteSize: integer().notNull(),
+	codiffVersion: text().notNull(),
+	commentsImportedAt: nullableTimestampColumn(),
+	createdAt: timestampColumn(),
+	id: idColumn().primaryKey(),
+	objectKey: text().notNull(),
+	schemaVersion: integer().notNull(),
+	sessionId: text(),
+	sha256: text().notNull(),
+	sharedByEmail: text(),
+	sharedByName: text(),
+	sharedByUserId: text().references(() => user.id, { onDelete: "set null" }),
+	slug: text().notNull(),
+	sourceFileName: text().notNull(),
+	title: text().notNull(),
+	updatedAt: timestampColumn()
+}, (table) => [
+	uniqueIndex("Plan_slug_key").on(table.slug),
+	index("Plan_sharedByEmail_idx").on(table.sharedByEmail),
+	index("Plan_sharedByUserId_idx").on(table.sharedByUserId)
+]);
+const uploadIntent = sqliteTable("UploadIntent", {
+	claimedAt: nullableTimestampColumn(),
+	code: text().notNull(),
+	createdAt: timestampColumn(),
+	expiresAt: integer({ mode: "timestamp" }).notNull(),
+	id: idColumn().primaryKey(),
+	secretHash: text().notNull(),
+	sharedByUserId: text().references(() => user.id, { onDelete: "set null" }),
+	shareKind: text({ enum: shareKind }).notNull().default("walkthrough"),
+	status: text({ enum: [
+		"pending",
+		"claimed",
+		"uploaded"
+	] }).notNull().default("pending"),
+	updatedAt: timestampColumn(),
+	uploadTokenHash: text(),
+	walkthroughSlug: text()
+}, (table) => [uniqueIndex("UploadIntent_code_key").on(table.code), index("UploadIntent_sharedByUserId_idx").on(table.sharedByUserId)]);
+const shareCommentThread = sqliteTable("ShareCommentThread", {
+	anchorJson: text(),
+	createdAt: timestampColumn(),
+	filePath: text(),
+	id: idColumn().primaryKey(),
+	kind: text({ enum: shareCommentThreadKind }).notNull(),
+	lineNumber: integer(),
+	planId: text().references(() => plan.id, { onDelete: "cascade" }),
+	resolvedAt: nullableTimestampColumn(),
+	sectionId: text(),
+	side: text({ enum: ["additions", "deletions"] }),
+	sourceThreadId: text(),
+	startLineNumber: integer(),
+	startSide: text({ enum: ["additions", "deletions"] }),
+	status: text({ enum: shareCommentThreadStatus }).notNull().default("open"),
+	updatedAt: timestampColumn(),
+	walkthroughId: text().references(() => walkthrough.id, { onDelete: "cascade" })
+}, (table) => [
+	check("ShareCommentThread_parent_check", sql`(${table.planId} is not null and ${table.walkthroughId} is null) or (${table.planId} is null and ${table.walkthroughId} is not null)`),
+	index("ShareCommentThread_planId_createdAt_idx").on(table.planId, table.createdAt),
+	index("ShareCommentThread_walkthroughId_createdAt_idx").on(table.walkthroughId, table.createdAt),
+	uniqueIndex("ShareCommentThread_planId_sourceThreadId_key").on(table.planId, table.sourceThreadId),
+	uniqueIndex("ShareCommentThread_walkthroughId_sourceThreadId_key").on(table.walkthroughId, table.sourceThreadId)
+]);
+const shareCommentMessage = sqliteTable("ShareCommentMessage", {
+	authorImage: text(),
+	authorName: text().notNull(),
+	authorUserId: text().references(() => user.id, { onDelete: "set null" }),
+	authorUsername: text(),
+	body: text().notNull(),
+	createdAt: timestampColumn(),
+	id: idColumn().primaryKey(),
+	sourceMessageId: text(),
+	threadId: text().notNull().references(() => shareCommentThread.id, { onDelete: "cascade" }),
+	updatedAt: timestampColumn()
+}, (table) => [
+	index("ShareCommentMessage_authorUserId_idx").on(table.authorUserId),
+	index("ShareCommentMessage_threadId_createdAt_idx").on(table.threadId, table.createdAt),
+	uniqueIndex("ShareCommentMessage_threadId_sourceMessageId_key").on(table.threadId, table.sourceMessageId)
+]);
+const shareDailyUsage = sqliteTable("ShareDailyUsage", {
+	date: text().notNull(),
+	planCount: integer().notNull().default(0),
+	userId: text().notNull().references(() => user.id, { onDelete: "cascade" }),
+	walkthroughCount: integer().notNull().default(0)
+}, (table) => [primaryKey({
+	columns: [table.userId, table.date],
+	name: "ShareDailyUsage_userId_date_pkey"
+})]);
+const userRelations = relations(user, ({ many }) => ({
+	shareCommentMessages: many(shareCommentMessage),
+	shareDailyUsage: many(shareDailyUsage)
+}));
+const walkthroughRelations = relations(walkthrough, ({ many }) => ({
+	commentThreads: many(shareCommentThread),
+	files: many(walkthroughFile)
+}));
+const walkthroughFileRelations = relations(walkthroughFile, ({ one }) => ({ walkthrough: one(walkthrough, {
+	fields: [walkthroughFile.walkthroughId],
+	references: [walkthrough.id]
+}) }));
+const planRelations = relations(plan, ({ many }) => ({ commentThreads: many(shareCommentThread) }));
+const shareCommentThreadRelations = relations(shareCommentThread, ({ many, one }) => ({
+	messages: many(shareCommentMessage),
+	plan: one(plan, {
+		fields: [shareCommentThread.planId],
+		references: [plan.id]
+	}),
+	walkthrough: one(walkthrough, {
+		fields: [shareCommentThread.walkthroughId],
+		references: [walkthrough.id]
+	})
+}));
+const shareCommentMessageRelations = relations(shareCommentMessage, ({ one }) => ({
+	author: one(user, {
+		fields: [shareCommentMessage.authorUserId],
+		references: [user.id]
+	}),
+	thread: one(shareCommentThread, {
+		fields: [shareCommentMessage.threadId],
+		references: [shareCommentThread.id]
+	})
+}));
+const shareDailyUsageRelations = relations(shareDailyUsage, ({ one }) => ({ user: one(user, {
+	fields: [shareDailyUsage.userId],
+	references: [user.id]
+}) }));
+const schema = {
+	plan,
+	planRelations,
+	shareCommentMessage,
+	shareCommentMessageRelations,
+	shareCommentThread,
+	shareCommentThreadRelations,
+	shareDailyUsage,
+	shareDailyUsageRelations,
+	uploadIntent,
+	user,
+	userRelations,
+	walkthrough,
+	walkthroughFile,
+	walkthroughFileRelations,
+	walkthroughRelations
+};
+//#endregion
+export { schema as default, plan, planRelations, shareCommentMessage, shareCommentMessageRelations, shareCommentThread, shareCommentThreadKind, shareCommentThreadRelations, shareCommentThreadStatus, shareDailyUsage, shareDailyUsageRelations, shareKind, uploadIntent, user, userRelations, walkthrough, walkthroughFile, walkthroughFileRelations, walkthroughRelations };

package/dist/upload-intent.mjs

@@ -0,0 +1,48 @@
+//#region upload-intent.ts
+const encoder = new TextEncoder();
+const tokenVersion = "v1";
+const base64UrlEncode = (value) => btoa(String.fromCharCode(...value)).replaceAll("+", "-").replaceAll("/", "_").replaceAll("=", "");
+const base64UrlDecode = (value) => {
+	const padding = "=".repeat((4 - value.length % 4) % 4);
+	const decoded = atob(value.replaceAll("-", "+").replaceAll("_", "/") + padding);
+	return Uint8Array.from(decoded, (character) => character.charCodeAt(0));
+};
+const signingKey = (env) => {
+	const secret = env.BETTER_AUTH_SECRET?.trim();
+	if (!secret) throw new Error("Codiff sharing requires BETTER_AUTH_SECRET.");
+	return crypto.subtle.importKey("raw", encoder.encode(secret), {
+		hash: "SHA-256",
+		name: "HMAC"
+	}, false, ["sign", "verify"]);
+};
+const signedValue = (code, payload) => `${code}.${payload}`;
+const createUploadIntentSecret = async (env, code, expiresAt) => {
+	const nonce = /* @__PURE__ */ new Uint8Array(24);
+	crypto.getRandomValues(nonce);
+	const payload = [
+		tokenVersion,
+		expiresAt.getTime().toString(36),
+		base64UrlEncode(nonce)
+	].join(".");
+	const signature = await crypto.subtle.sign("HMAC", await signingKey(env), encoder.encode(signedValue(code, payload)));
+	return `${payload}.${base64UrlEncode(new Uint8Array(signature))}`;
+};
+const hashUploadIntentSecret = async (secret) => {
+	const digest = await crypto.subtle.digest("SHA-256", encoder.encode(secret));
+	return [...new Uint8Array(digest)].map((byte) => byte.toString(16).padStart(2, "0")).join("");
+};
+const verifyUploadIntentSecret = async (env, code, secret) => {
+	const parts = secret.split(".");
+	if (parts.length !== 4 || parts[0] !== tokenVersion) return null;
+	const [version, encodedExpiresAt, nonce, encodedSignature] = parts;
+	const expiresAtMs = Number.parseInt(encodedExpiresAt, 36);
+	if (version !== tokenVersion || !Number.isSafeInteger(expiresAtMs) || expiresAtMs <= 0 || !nonce || !encodedSignature) return null;
+	try {
+		const payload = `${version}.${encodedExpiresAt}.${nonce}`;
+		return await crypto.subtle.verify("HMAC", await signingKey(env), base64UrlDecode(encodedSignature), encoder.encode(signedValue(code, payload))) ? { expiresAt: new Date(expiresAtMs) } : null;
+	} catch {
+		return null;
+	}
+};
+//#endregion
+export { createUploadIntentSecret, hashUploadIntentSecret, verifyUploadIntentSecret };

package/dist/views.mjs

@@ -0,0 +1,142 @@
+import { FateRequestError, computed, dataView, field, list } from "@nkzw/fate/server";
+//#region views.ts
+const uploadIntentSecretHeader = "x-codiff-upload-secret";
+const isRecord = (value) => value !== null && typeof value === "object";
+const getSessionUserId = (value) => {
+	const result = isRecord(value) && isRecord(value.response) ? value.response : value;
+	const sessionUser = isRecord(result) ? result.user : null;
+	return isRecord(sessionUser) && typeof sessionUser.id === "string" && sessionUser.id ? sessionUser.id : null;
+};
+const sessionUserIds = /* @__PURE__ */ new WeakMap();
+const readContextSessionUserId = (context) => {
+	if (!context.auth) return Promise.resolve(null);
+	const existing = sessionUserIds.get(context.request);
+	if (existing) return existing;
+	const result = context.auth.api.getSession({
+		asResponse: false,
+		headers: context.request.headers
+	}).then(getSessionUserId);
+	sessionUserIds.set(context.request, result);
+	return result;
+};
+const canManageShare = () => computed({
+	resolve: async (_record, values, context) => Boolean(values.sharedByUserId && context?.auth && await readContextSessionUserId(context) === values.sharedByUserId),
+	select: { sharedByUserId: field("sharedByUserId") }
+});
+const canEditShareComment = () => computed({
+	resolve: async (_record, values, context) => Boolean(values.authorUserId && context?.auth && await readContextSessionUserId(context) === values.authorUserId),
+	select: { authorUserId: field("authorUserId") }
+});
+const sha256 = async (value) => {
+	const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(value));
+	return [...new Uint8Array(digest)].map((byte) => byte.toString(16).padStart(2, "0")).join("");
+};
+const protectedUploadIntentField = (fieldName) => computed({
+	resolve: async (_intent, values, context) => {
+		const secret = context?.request.headers.get(uploadIntentSecretHeader);
+		if (!secret || values.secretHash !== await sha256(secret)) throw new FateRequestError("NOT_FOUND", "Upload intent not found.");
+		return values.value;
+	},
+	select: {
+		secretHash: field("secretHash"),
+		value: field(fieldName)
+	}
+});
+const uploadIntentDataView = dataView("UploadIntent")({
+	expiresAt: protectedUploadIntentField("expiresAt"),
+	id: true,
+	shareKind: protectedUploadIntentField("shareKind"),
+	status: protectedUploadIntentField("status"),
+	walkthroughSlug: protectedUploadIntentField("walkthroughSlug")
+});
+const shareCommentMessageDataView = dataView("ShareCommentMessage")({
+	authorImage: true,
+	authorName: true,
+	authorUsername: true,
+	body: true,
+	canEdit: canEditShareComment(),
+	createdAt: true,
+	id: true,
+	threadId: true,
+	updatedAt: true
+});
+const shareCommentThreadDataView = dataView("ShareCommentThread")({
+	anchorJson: true,
+	createdAt: true,
+	filePath: true,
+	id: true,
+	kind: true,
+	lineNumber: true,
+	messages: list(shareCommentMessageDataView, { orderBy: [{ createdAt: "asc" }, { id: "asc" }] }),
+	planId: true,
+	resolvedAt: true,
+	sectionId: true,
+	side: true,
+	startLineNumber: true,
+	startSide: true,
+	status: true,
+	updatedAt: true,
+	walkthroughId: true
+});
+const walkthroughDataView = dataView("Walkthrough")({
+	branch: true,
+	byteSize: true,
+	canDelete: canManageShare(),
+	canResolveComments: canManageShare(),
+	codiffVersion: true,
+	commentThreads: list(shareCommentThreadDataView, { orderBy: [{ createdAt: "asc" }, { id: "asc" }] }),
+	createdAt: true,
+	description: true,
+	id: true,
+	pullRequestNumber: true,
+	pullRequestTitle: true,
+	pullRequestUrl: true,
+	repositoryHost: true,
+	repositoryName: true,
+	repositoryOwner: true,
+	repositoryUrl: true,
+	schemaVersion: true,
+	sha256: true,
+	slug: true,
+	sourceType: true,
+	title: true,
+	updatedAt: true
+});
+const planDataView = dataView("Plan")({
+	agent: true,
+	byteSize: true,
+	canDelete: canManageShare(),
+	canResolveComments: canManageShare(),
+	codiffVersion: true,
+	commentThreads: list(shareCommentThreadDataView, { orderBy: [{ createdAt: "asc" }, { id: "asc" }] }),
+	createdAt: true,
+	id: true,
+	schemaVersion: true,
+	slug: true,
+	sourceFileName: true,
+	title: true,
+	updatedAt: true
+});
+const shareStatsDayDataView = dataView("ShareStatsDay")({
+	date: true,
+	id: true,
+	mergeRequestWalkthroughs: true,
+	plans: true,
+	walkthroughs: true
+});
+const shareStatsDataView = dataView("ShareStats")({
+	days: list(shareStatsDayDataView),
+	id: true,
+	maxDailyShares: true,
+	totalMergeRequestWalkthroughs: true,
+	totalPlans: true,
+	totalWalkthroughs: true
+});
+const SharingRoot = {
+	planBySlug: planDataView,
+	sharingStats: shareStatsDataView,
+	uploadIntentByCode: uploadIntentDataView,
+	walkthroughBySlug: walkthroughDataView
+};
+//#endregion
+export { SharingRoot, getSessionUserId, planDataView, shareCommentMessageDataView, shareCommentThreadDataView, shareStatsDataView, shareStatsDayDataView, uploadIntentDataView, uploadIntentSecretHeader, walkthroughDataView };

package/fate.test.ts

@@ -0,0 +1,21 @@
+import { createLiveEventBus } from '@nkzw/fate/server';
+import { expect, test } from 'vite-plus/test';
+import { createSharingFateServer } from './fate.ts';
+
+const fateServer = createSharingFateServer({
+  live: createLiveEventBus(),
+  providerLabel: 'GitHub',
+});
+
+test('enables live subscriptions for every shared service entity', () => {
+  expect(fateServer.manifest.live).toEqual(fateServer.manifest.types);
+  expect(Object.keys(fateServer.manifest.live)).toEqual([
+    'Plan',
+    'ShareCommentMessage',
+    'ShareCommentThread',
+    'ShareStats',
+    'ShareStatsDay',
+    'UploadIntent',
+    'Walkthrough',
+  ]);
+});