@highstate/backend 0.17.0 → 0.18.0

package/src/database/migration.ts

@@ -0,0 +1,126 @@
+import type { Logger } from "pino"
+import { readFile } from "node:fs/promises"
+import { dirname, join, resolve } from "node:path"
+import { fileURLToPath } from "node:url"
+import { resolve as importMetaResolve } from "import-meta-resolve"
+import { BackendError } from "../shared"
+
+export type MigrationClient = {
+  $transaction<T>(callback: (tx: unknown) => Promise<T>): Promise<T>
+  $executeRawUnsafe(query: string): Promise<number>
+}
+
+export type MigrationPack = {
+  type: "backend" | "project"
+  schemaPath: string
+  migrationNames: string[]
+}
+
+export const migrationPacks = {
+  "backend/sqlite": {
+    type: "backend" as const,
+    schemaPath: "backend/sqlite",
+    migrationNames: [
+      //
+      "20250928124105_initial_migration",
+    ],
+  },
+  project: {
+    type: "project" as const,
+    schemaPath: "project",
+    migrationNames: [
+      //
+      "20250928130725_initial_migration",
+      "20260123000000_add_instance_state_self_hash",
+    ],
+  },
+}
+
+export const backendDatabaseVersion = migrationPacks["backend/sqlite"].migrationNames.length
+export const projectDatabaseVersion = migrationPacks.project.migrationNames.length
+
+export async function migrateDatabase(
+  client: MigrationClient,
+  migrationPack: MigrationPack,
+  currentVersion: number,
+  writeVersion: (version: number) => Promise<void>,
+  logger: Logger,
+): Promise<void> {
+  const { type, schemaPath, migrationNames } = migrationPack
+  const targetVersion = migrationNames.length
+
+  const backendIndexPath = importMetaResolve("@highstate/backend", import.meta.url)
+  const backendRootPath = join(dirname(fileURLToPath(backendIndexPath)), "..")
+  const migrationsDir = resolve(backendRootPath, `prisma`, schemaPath, "migrations")
+
+  logger.debug(`migrations dir: "%s"`, migrationsDir)
+
+  if (currentVersion > targetVersion) {
+    throw new BackendError(
+      `The version of the ${type} database (${currentVersion}) is newer than expected (${targetVersion}). Do you need to upgrade Highstate?`,
+    )
+  }
+
+  for (let version = currentVersion; version < migrationNames.length; version++) {
+    const nextVersion = version + 1
+    const nextMigrationName = migrationNames[nextVersion - 1]
+
+    logger.info(
+      `applying migration for %s database, %d -> %d: %s`,
+      type,
+      version,
+      nextVersion,
+      nextMigrationName,
+    )
+
+    const migrationPath = join(migrationsDir, nextMigrationName, "migration.sql")
+    const content = await readFile(migrationPath, "utf-8")
+
+    const statements = splitToStatements(content)
+
+    // execute each statement and update the version in a single transaction
+    await client.$transaction(async tx => {
+      for (const statement of statements) {
+        await (tx as MigrationClient).$executeRawUnsafe(statement)
+      }
+
+      await writeVersion(nextVersion)
+    })
+  }
+
+  logger.info(`database is up to date at version %d`, migrationNames.length)
+}
+
+function splitToStatements(sql: string): string[] {
+  const statements: string[] = []
+  let currentStatement = ""
+  let insideString = false
+  let stringChar = ""
+
+  for (let i = 0; i < sql.length; i++) {
+    const char = sql[i]
+
+    if ((char === "'" || char === '"') && !insideString) {
+      insideString = true
+      stringChar = char
+    } else if (char === stringChar && insideString) {
+      insideString = false
+      stringChar = ""
+    }
+
+    if (char === ";" && !insideString) {
+      if (currentStatement.trim().length > 0) {
+        statements.push(currentStatement.trim())
+      }
+      currentStatement = ""
+    } else {
+      currentStatement += char
+    }
+  }
+
+  if (currentStatement.trim().length > 0) {
+    statements.push(currentStatement.trim())
+  }
+
+  return statements
+}

package/src/test-utils/database.ts

@@ -4,12 +4,17 @@ import { constants } from "node:fs"
 import { access, mkdtemp, rm } from "node:fs/promises"
 import { hostname, tmpdir } from "node:os"
 import { join } from "node:path"
-import { PrismaLibSQL } from "@prisma/adapter-libsql"
+import { PrismaLibSql } from "@prisma/adapter-libsql"
 import { generateIdentity, identityToRecipient } from "age-encryption"
-import { type DatabaseManager, ensureWellKnownEntitiesCreated } from "../database"
+import { createProjectLogger } from "../common"
+import {
+  type DatabaseManager,
+  ensureWellKnownEntitiesCreated,
+  migrateDatabase,
+  migrationPacks,
+} from "../database"
 import { PrismaClient as BackendPrismaClient } from "../database/_generated/backend/sqlite/client"
 import { getInitialBackendUnlockMethodMeta } from "../database/local/backend"
-import { migrateDatabase } from "../database/migrate"
 import {
   type BackendDatabase as BackendDatabaseClient,
   ProjectDatabase as ProjectDatabaseClient,
@@ -58,12 +63,15 @@ export class TestDatabaseManager implements DatabaseManager {
   async _forProject(projectId: string): Promise<ProjectDatabase> {
     const tempPath = await this.createTempPath()
     const projectUrl = `file:${join(tempPath, `${projectId}.db`)}`
+    const logger = createProjectLogger(this.logger, projectId)
 
-    await migrateDatabase(projectUrl, "project", undefined, this.logger)
-
-    return new ProjectDatabaseClient({
-      adapter: new PrismaLibSQL({ url: projectUrl }),
+    const client = new ProjectDatabaseClient({
+      adapter: new PrismaLibSql({ url: projectUrl }),
     })
+
+    await migrateDatabase(client, migrationPacks.project, 0, () => Promise.resolve(), logger)
+
+    return client
   }
 
   static async create(
@@ -75,20 +83,26 @@ export class TestDatabaseManager implements DatabaseManager {
     const tempPath = await mkdtemp(join(tempRoot, "highstate"))
     const backendUrl = `file:${join(tempPath, "backend.db")}`
 
-    await migrateDatabase(backendUrl, "backend/sqlite", undefined, logger)
-
-    const backend = new BackendPrismaClient({
-      adapter: new PrismaLibSQL({ url: backendUrl }),
+    const backendClient = new BackendPrismaClient({
+      adapter: new PrismaLibSql({ url: backendUrl }),
     }) as BackendDatabaseClient
 
-    await ensureWellKnownEntitiesCreated(backend)
+    await migrateDatabase(
+      backendClient,
+      migrationPacks["backend/sqlite"],
+      0,
+      () => Promise.resolve(),
+      logger,
+    )
+
+    await ensureWellKnownEntitiesCreated(backendClient)
 
     if (isEncryptionEnabled) {
       const identity = await generateIdentity()
       const recipient = await identityToRecipient(identity)
       const meta = getInitialBackendUnlockMethodMeta(hostname())
 
-      await backend.backendUnlockMethod.create({
+      await backendClient.backendUnlockMethod.create({
         data: {
           recipient,
           meta,
@@ -96,7 +110,7 @@ export class TestDatabaseManager implements DatabaseManager {
       })
     }
 
-    return new TestDatabaseManager(backend, logger, isEncryptionEnabled)
+    return new TestDatabaseManager(backendClient, logger, isEncryptionEnabled)
   }
 
   private async createTempPath(): Promise<string> {

package/dist/database/local/prisma.config.js

@@ -1,26 +0,0 @@
-import '../../chunk-I7BWSAN6.js';
-import { PrismaLibSQL } from '@prisma/adapter-libsql';
-import { defineConfig } from 'prisma/config';
-
-if (!process.env.HIGHSTATE_MIGRATION_DATABASE_SCHEMA_PATH) {
-  throw new Error("HIGHSTATE_MIGRATION_DATABASE_SCHEMA_PATH is not set");
-}
-var prisma_config_default = defineConfig({
-  experimental: {
-    adapter: true
-  },
-  schema: `../../../prisma/${process.env.HIGHSTATE_MIGRATION_DATABASE_SCHEMA_PATH}`,
-  async adapter() {
-    if (!process.env.HIGHSTATE_MIGRATION_DATABASE_URL) {
-      throw new Error("HIGHSTATE_MIGRATION_DATABASE_URL is not set");
-    }
-    return new PrismaLibSQL({
-      url: process.env.HIGHSTATE_MIGRATION_DATABASE_URL,
-      encryptionKey: process.env.HIGHSTATE_MIGRATION_DATABASE_ENCRYPTION_KEY || void 0
-    });
-  }
-});
-
-export { prisma_config_default as default };
-//# sourceMappingURL=prisma.config.js.map
-//# sourceMappingURL=prisma.config.js.map

package/dist/database/local/prisma.config.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/database/local/prisma.config.ts"],"names":[],"mappings":";;;;AAGA,IAAI,CAAC,OAAA,CAAQ,GAAA,CAAI,wCAAA,EAA0C;AACzD,EAAA,MAAM,IAAI,MAAM,qDAAqD,CAAA;AACvE;AAEA,IAAO,wBAAQ,YAAA,CAAa;AAAA,EAC1B,YAAA,EAAc;AAAA,IACZ,OAAA,EAAS;AAAA,GACX;AAAA,EAEA,MAAA,EAAQ,CAAA,gBAAA,EAAmB,OAAA,CAAQ,GAAA,CAAI,wCAAwC,CAAA,CAAA;AAAA,EAE/E,MAAM,OAAA,GAAU;AACd,IAAA,IAAI,CAAC,OAAA,CAAQ,GAAA,CAAI,gCAAA,EAAkC;AACjD,MAAA,MAAM,IAAI,MAAM,6CAA6C,CAAA;AAAA,IAC/D;AAEA,IAAA,OAAO,IAAI,YAAA,CAAa;AAAA,MACtB,GAAA,EAAK,QAAQ,GAAA,CAAI,gCAAA;AAAA,MACjB,aAAA,EAAe,OAAA,CAAQ,GAAA,CAAI,2CAAA,IAA+C;AAAA,KAC3E,CAAA;AAAA,EACH;AACF,CAAC","file":"prisma.config.js","sourcesContent":["import { PrismaLibSQL } from \"@prisma/adapter-libsql\"\nimport { defineConfig } from \"prisma/config\"\n\nif (!process.env.HIGHSTATE_MIGRATION_DATABASE_SCHEMA_PATH) {\n  throw new Error(\"HIGHSTATE_MIGRATION_DATABASE_SCHEMA_PATH is not set\")\n}\n\nexport default defineConfig({\n  experimental: {\n    adapter: true,\n  },\n\n  schema: `../../../prisma/${process.env.HIGHSTATE_MIGRATION_DATABASE_SCHEMA_PATH}`,\n\n  async adapter() {\n    if (!process.env.HIGHSTATE_MIGRATION_DATABASE_URL) {\n      throw new Error(\"HIGHSTATE_MIGRATION_DATABASE_URL is not set\")\n    }\n\n    return new PrismaLibSQL({\n      url: process.env.HIGHSTATE_MIGRATION_DATABASE_URL,\n      encryptionKey: process.env.HIGHSTATE_MIGRATION_DATABASE_ENCRYPTION_KEY || undefined,\n    })\n  },\n})\n"]}

package/src/database/local/prisma.config.ts

@@ -1,25 +0,0 @@
-import { PrismaLibSQL } from "@prisma/adapter-libsql"
-import { defineConfig } from "prisma/config"
-
-if (!process.env.HIGHSTATE_MIGRATION_DATABASE_SCHEMA_PATH) {
-  throw new Error("HIGHSTATE_MIGRATION_DATABASE_SCHEMA_PATH is not set")
-}
-
-export default defineConfig({
-  experimental: {
-    adapter: true,
-  },
-
-  schema: `../../../prisma/${process.env.HIGHSTATE_MIGRATION_DATABASE_SCHEMA_PATH}`,
-
-  async adapter() {
-    if (!process.env.HIGHSTATE_MIGRATION_DATABASE_URL) {
-      throw new Error("HIGHSTATE_MIGRATION_DATABASE_URL is not set")
-    }
-
-    return new PrismaLibSQL({
-      url: process.env.HIGHSTATE_MIGRATION_DATABASE_URL,
-      encryptionKey: process.env.HIGHSTATE_MIGRATION_DATABASE_ENCRYPTION_KEY || undefined,
-    })
-  },
-})

package/src/database/migrate.ts

@@ -1,35 +0,0 @@
-import type { Logger } from "pino"
-import { join } from "node:path"
-import { fileURLToPath } from "node:url"
-import { execa } from "execa"
-import { resolve } from "import-meta-resolve"
-import { detectPackageManager } from "nypm"
-
-export async function migrateDatabase(
-  databaseUrl: string,
-  schemaPath: "backend/sqlite" | "project",
-  masterKey: string | undefined,
-  logger: Logger,
-): Promise<void> {
-  logger.info("applying database migrations")
-
-  const backendIndexPath = resolve("@highstate/backend", import.meta.url)
-  const backendRootPath = join(fileURLToPath(backendIndexPath), "..")
-
-  const packageManager = await detectPackageManager(backendRootPath)
-  if (!packageManager) {
-    throw new Error("Could not detect package manager to run migrations")
-  }
-
-  const hasCorepack = await execa`"corepack" --version`.then(() => true).catch(() => false)
-  const command = hasCorepack ? `corepack ${packageManager.command}` : packageManager.command
-
-  await execa({
-    cwd: backendRootPath,
-    env: {
-      HIGHSTATE_MIGRATION_DATABASE_SCHEMA_PATH: schemaPath,
-      HIGHSTATE_MIGRATION_DATABASE_URL: databaseUrl,
-      HIGHSTATE_MIGRATION_DATABASE_ENCRYPTION_KEY: masterKey ?? "",
-    },
-  })`${command} migrate`
-}