sailfork / t3code-github / apps/ server/ src/ orchestration-v2/ ProjectSettingsUpgrade.integration.test.ts

import * as NodeCrypto from "@effect/platform-node/NodeCrypto";
import * as NodeServices from "@effect/platform-node/NodeServices";
import * as McpProviderSessions from "@t3tools/provider-core/server/McpProviderSessions";
import { assert, it } from "@effect/vitest";
import { ProjectId } from "@t3tools/contracts";
import * as Effect from "effect/Effect";
import * as FileSystem from "effect/FileSystem";
import * as Layer from "effect/Layer";
import * as Path from "effect/Path";
import * as Schema from "effect/Schema";
import * as Stream from "effect/Stream";
import * as SqlClient from "effect/sql/SqlClient";

import * as CheckpointStore from "../checkpointing/CheckpointStore.ts";
import * as ServerConfig from "../config.ts";
import * as GitWorkflow from "../git/GitWorkflowService.ts";
import * as NodeSqliteClient from "@t3tools/shared/nodeSqliteClient";

import * as McpSessionRegistryTestkit from "../mcp/McpSessionRegistry.testkit.ts";
import * as SqlitePersistence from "../persistence/Sqlite.ts";
import { runMigrations } from "../persistence/Migrations.ts";
import * as ProjectEnrichmentService from "../project/ProjectEnrichmentService.ts";
import * as ProjectService from "../project/ProjectService.ts";
import * as ProviderInstanceRegistry from "../provider/ProviderInstanceRegistry.ts";
import * as ServerSettings from "../serverSettings.ts";
import * as SourceControlProviderRegistry from "../sourceControl/SourceControlProviderRegistry.ts";
import * as VcsDriverRegistry from "../vcs/VcsDriverRegistry.ts";
import * as VcsProcess from "../vcs/VcsProcess.ts";
import * as WorkspacePaths from "../workspace/WorkspacePaths.ts";
import * as LegacyV1ThreadImporter from "./legacy/LegacyV1ThreadImporter.ts";
import * as RuntimeLayer from "./runtimeLayer.ts";

const projectId = ProjectId.make("project:upgrade");
const icon = { kind: "emoji", emoji: "🦊" } as const;
const encodeJson = Schema.encodeSync(Schema.fromJsonString(Schema.Unknown));

const expectedSettings = {
  default_thread_env_mode: "worktree",
  auto_pull: 1,
  favicon_path: "brand/icon.svg",
  project_icon_json: encodeJson(icon),
};

const readSettings = Effect.gen(function* () {
  const sql = yield* SqlClient.SqlClient;
  const rows = yield* sql<typeof expectedSettings>`
    SELECT default_thread_env_mode, auto_pull, favicon_path, project_icon_json
    FROM projection_projects
    WHERE project_id = ${projectId}
  `;
  return rows[0];
});

const seedV1Database = Effect.gen(function* () {
  const sql = yield* SqlClient.SqlClient;
  yield* runMigrations({ toMigrationInclusive: 54 });
  const events = [
    {
      type: "project.created",
      payload: {
        projectId,
        title: "Upgrade",
        workspaceRoot: "/work/upgrade",
        defaultModelSelection: null,
        faviconPath: null,
        projectIcon: null,
        scripts: [],
        createdAt: "2026-01-01T00:00:00.000Z",
        updatedAt: "2026-01-01T00:00:00.000Z",
      },
    },
    {
      type: "project.meta-updated",
      payload: {
        projectId,
        defaultThreadEnvMode: "worktree",
        autoPull: true,
        faviconPath: "brand/icon.svg",
        projectIcon: icon,
        updatedAt: "2026-01-02T00:00:00.000Z",
      },
    },
  ] as const;
  for (const [version, event] of events.entries()) {
    yield* sql`
      INSERT INTO orchestration_events (
        event_id, aggregate_kind, stream_id, stream_version, event_type, occurred_at,
        command_id, causation_event_id, correlation_id, actor_kind, payload_json, metadata_json
      ) VALUES (
        ${`v1:${event.type}`}, 'project', ${projectId}, ${version}, ${event.type},
        ${event.payload.updatedAt}, ${`command:${event.type}`}, NULL, ${`command:${event.type}`},
        'client', ${encodeJson(event.payload)}, '{}'
      )
    `;
  }
  yield* sql`
    INSERT INTO projection_projects (
      project_id, title, workspace_root, default_model_selection_json, default_thread_env_mode,
      auto_pull, favicon_path, project_icon_json, scripts_json, created_at, updated_at, deleted_at
    ) VALUES (
      ${projectId}, 'Upgrade', '/work/upgrade', NULL, ${expectedSettings.default_thread_env_mode},
      1, ${expectedSettings.favicon_path}, ${expectedSettings.project_icon_json}, '[]',
      '2026-01-01T00:00:00.000Z', '2026-01-02T00:00:00.000Z', NULL
    )
  `;
  yield* sql`
    INSERT INTO projection_state (projector, last_applied_sequence, updated_at)
    VALUES ('projection.projects', 2, '2026-01-02T00:00:00.000Z')
  `;
});

const unusedEnrichment = {
  repositoryIdentity: null,
  faviconPath: null,
  repositoryIdentityResolved: false,
};

const layerRuntime = (dbPath: string) => {
  const layerPlatform = Layer.merge(
    Layer.mergeAll(NodeServices.layer, NodeCrypto.layer),
    Layer.mock(SourceControlProviderRegistry.SourceControlProviderRegistry)({
      resolveLink: () => Effect.die("unused"),
    }),
  );
  const layerServerConfig = ServerConfig.layerTest(process.cwd(), {
    prefix: "t3-project-upgrade-",
  });
  const layerCheckpointStore = CheckpointStore.layer.pipe(
    Layer.provide(
      VcsDriverRegistry.layer.pipe(
        Layer.provide(VcsProcess.layer),
        Layer.provide(layerServerConfig),
        Layer.provide(layerPlatform),
      ),
    ),
  );
  return Layer.mergeAll(
    RuntimeLayer.layer.pipe(Layer.provide(RuntimeLayer.layerProjectService)),
    RuntimeLayer.layerProjectService,
  ).pipe(
    Layer.provide(
      Layer.mock(ProjectEnrichmentService.ProjectEnrichmentService)({
        peek: () => Effect.succeed(unusedEnrichment),
        getAvailable: () => Effect.succeed(unusedEnrichment),
        invalidate: () => Effect.void,
      }),
    ),
    Layer.provide(
      Layer.mock(WorkspacePaths.WorkspacePaths)({
        normalizeWorkspaceRoot: (workspaceRoot) => Effect.succeed(workspaceRoot),
      }),
    ),
    Layer.provide(McpSessionRegistryTestkit.layer),
    Layer.provide(McpProviderSessions.layer),
    Layer.provideMerge(SqlitePersistence.layerFromPath(dbPath)),
    Layer.provide(layerCheckpointStore),
    Layer.provide(layerServerConfig),
    Layer.provide(ServerSettings.layerTest()),
    Layer.provide(
      Layer.succeed(ProviderInstanceRegistry.ProviderInstanceRegistry, {
        getInstance: () => Effect.undefined,
        listInstances: Effect.succeed([]),
        listUnavailable: Effect.succeed([]),
        streamChanges: Stream.empty,
        subscribeChanges: Effect.never,
      }),
    ),
    Layer.provide(
      Layer.mock(GitWorkflow.GitWorkflowService)({
        pruneWorktrees: () => Effect.void,
      }),
    ),
    Layer.provide(layerPlatform),
  );
};

it.live("keeps project settings through the V2 migrations and the first V2 boot", () =>
  Effect.scoped(
    Effect.gen(function* () {
      const fs = yield* FileSystem.FileSystem;
      const path = yield* Path.Path;
      const stateDir = yield* fs.makeTempDirectoryScoped({ prefix: "t3-project-upgrade-" });
      const dbPath = path.join(stateDir, "statev2.sqlite");

      yield* seedV1Database.pipe(Effect.provide(NodeSqliteClient.layer({ filename: dbPath })));
      yield* Effect.gen(function* () {
        yield* (yield* LegacyV1ThreadImporter.LegacyV1ThreadImporter).reconcileShells;
        assert.deepEqual(yield* readSettings, expectedSettings);
        const project = yield* (yield* ProjectService.ProjectService).getById(projectId);
        assert.equal(project._tag, "Some");
      }).pipe(Effect.provide(layerRuntime(dbPath)));
    }),
  ).pipe(Effect.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer))),
);