@coreframe/scripts 0.0.0 → 0.1.0

package/dist/deploy/migrations.js

@@ -0,0 +1,203 @@
+import { access, readFile, readdir } from "node:fs/promises";
+import { basename, join, relative, resolve } from "node:path";
+import { HELD_MIGRATIONS_FOLDER, MIGRATIONS_FOLDER } from "../db/config.js";
+const staticBlockedPatterns = [
+    {
+        code: "drop-schema-object",
+        pattern: /\bdrop\s+(?:table|view|materialized\s+view|index|sequence|type|schema|function|trigger|policy)\b/giu,
+        reason: "drops schema that the currently deployed app may still depend on",
+    },
+    {
+        code: "drop-column",
+        pattern: /\balter\s+table\b[^;]*?\bdrop\s+column\b/giu,
+        reason: "removes a column that the currently deployed app may still read or write",
+    },
+    {
+        code: "drop-constraint",
+        pattern: /\balter\s+table\b[^;]*?\bdrop\s+constraint\b/giu,
+        reason: "removes a constraint outside the staged contract phase",
+    },
+    {
+        code: "truncate",
+        pattern: /\btruncate\b/giu,
+        reason: "removes data outside the deploy-safe migration path",
+    },
+    {
+        code: "rename-table-or-column",
+        pattern: /\balter\s+table\b[^;]*?\brename(?:\s+column)?\b/giu,
+        reason: "renames schema in a way old and new app versions cannot both address",
+    },
+    {
+        code: "rewrite-column-type",
+        pattern: /\balter\s+table\b[^;]*?\balter\s+column\b[^;]*?\btype\b/giu,
+        reason: "rewrites a column type outside a staged expand/contract rollout",
+    },
+    {
+        code: "set-not-null",
+        pattern: /\balter\s+table\b[^;]*?\balter\s+column\b[^;]*?\bset\s+not\s+null\b/giu,
+        reason: "enforces NOT NULL before a separate backfill and verification step",
+    },
+    {
+        code: "set-default",
+        pattern: /\balter\s+table\b[^;]*?\balter\s+column\b[^;]*?\bset\s+default\b/giu,
+        reason: "changes default write behavior while old app code may still be running",
+    },
+    {
+        code: "broad-update",
+        pattern: /\bupdate\b/giu,
+        reason: "changes data outside a separately reviewed backfill or held migration",
+    },
+    {
+        code: "broad-delete",
+        pattern: /\bdelete\s+from\b/giu,
+        reason: "removes data outside a held migration",
+    },
+];
+export async function collectDeployMigrationFiles(cwd = process.cwd()) {
+    return collectDrizzleMigrationFiles(resolve(cwd, MIGRATIONS_FOLDER), cwd);
+}
+export async function collectHeldMigrationFiles(cwd = process.cwd()) {
+    return collectFlatSqlFiles(resolve(cwd, HELD_MIGRATIONS_FOLDER), cwd);
+}
+export async function scanDeployMigrationFiles(migrations) {
+    const results = await Promise.all(migrations.map(async (migration) => {
+        const sql = await readFile(migration.path, "utf8");
+        return {
+            migration,
+            risks: scanMigrationSql(sql),
+        };
+    }));
+    return results.filter((result) => result.risks.length > 0);
+}
+export function scanMigrationSql(sql) {
+    const maskedSql = maskSql(sql);
+    const createdTables = collectCreatedTables(maskedSql);
+    const risks = [];
+    for (const blocked of staticBlockedPatterns) {
+        for (const match of maskedSql.matchAll(blocked.pattern)) {
+            risks.push(riskForMatch(sql, match, blocked.code, blocked.reason));
+        }
+    }
+    for (const match of maskedSql.matchAll(/\balter\s+table\s+(?:if\s+exists\s+|only\s+)?(?<table>(?:"[^"]+"|\w+)(?:\s*\.\s*(?:"[^"]+"|\w+))?)\s+add\s+column\b[^;]*?\bnot\s+null\b/giu)) {
+        if (!createdTables.has(normalizeIdentifier(match.groups?.table))) {
+            risks.push(riskForMatch(sql, match, "add-not-null-column", "adds a required column to an existing table before a separate compatibility rollout"));
+        }
+    }
+    for (const match of maskedSql.matchAll(/\balter\s+table\s+(?:if\s+exists\s+|only\s+)?(?<table>(?:"[^"]+"|\w+)(?:\s*\.\s*(?:"[^"]+"|\w+))?)\s+add\s+constraint\b[^;]*?\b(?:foreign\s+key|unique|primary\s+key|check)\b/giu)) {
+        if (!createdTables.has(normalizeIdentifier(match.groups?.table))) {
+            risks.push(riskForMatch(sql, match, "add-constraint", "enforces a constraint on an existing table before a separate validation step"));
+        }
+    }
+    for (const match of maskedSql.matchAll(/\bcreate\s+unique\s+index(?:\s+concurrently)?(?:\s+if\s+not\s+exists)?\s+(?:"[^"]+"|\w+)\s+on\s+(?<table>(?:"[^"]+"|\w+)(?:\s*\.\s*(?:"[^"]+"|\w+))?)/giu)) {
+        if (!createdTables.has(normalizeIdentifier(match.groups?.table))) {
+            risks.push(riskForMatch(sql, match, "create-unique-index", "adds uniqueness to existing data before a separate dedupe and validation step"));
+        }
+    }
+    return risks.sort((left, right) => left.line - right.line || left.code.localeCompare(right.code));
+}
+export function formatMigrationScanFailures(results) {
+    return results
+        .flatMap((result) => result.risks.map((risk) => `${result.migration.relativePath}:${risk.line} ${risk.code}: ${risk.reason} (${risk.match.trim()})`))
+        .join("\n");
+}
+export function formatMigrationList(migrations) {
+    if (migrations.length === 0) {
+        return "No migration files found.";
+    }
+    return migrations.map((migration) => `- ${migration.relativePath}`).join("\n");
+}
+function collectCreatedTables(sql) {
+    const tables = new Set();
+    for (const match of sql.matchAll(/\bcreate\s+(?:temporary\s+|temp\s+)?table\s+(?:if\s+not\s+exists\s+)?(?<table>(?:"[^"]+"|\w+)(?:\s*\.\s*(?:"[^"]+"|\w+))?)/giu)) {
+        tables.add(normalizeIdentifier(match.groups?.table));
+    }
+    return tables;
+}
+async function collectDrizzleMigrationFiles(migrationsPath, cwd) {
+    const entries = await readDirectoryOrEmpty(migrationsPath);
+    const migrations = [];
+    for (const entry of entries) {
+        const entryPath = join(migrationsPath, entry.name);
+        if (entry.isDirectory()) {
+            const migrationPath = join(entryPath, "migration.sql");
+            if (await fileExists(migrationPath)) {
+                migrations.push(migrationFileFromPath(migrationPath, cwd, entry.name));
+            }
+            continue;
+        }
+        if (entry.isFile() && entry.name.endsWith(".sql")) {
+            migrations.push(migrationFileFromPath(entryPath, cwd, entry.name.replace(/\.sql$/u, "")));
+        }
+    }
+    return migrations.sort((left, right) => left.id.localeCompare(right.id));
+}
+async function collectFlatSqlFiles(directory, cwd) {
+    const entries = await readDirectoryOrEmpty(directory);
+    const migrations = entries
+        .filter((entry) => entry.isFile() && entry.name.endsWith(".sql"))
+        .map((entry) => migrationFileFromPath(join(directory, entry.name), cwd, entry.name.replace(/\.sql$/u, "")));
+    return migrations.sort((left, right) => left.id.localeCompare(right.id));
+}
+async function readDirectoryOrEmpty(directory) {
+    try {
+        return await readdir(directory, { withFileTypes: true });
+    }
+    catch (error) {
+        if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+            return [];
+        }
+        throw error;
+    }
+}
+async function fileExists(path) {
+    try {
+        await access(path);
+        return true;
+    }
+    catch (error) {
+        if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+            return false;
+        }
+        throw error;
+    }
+}
+function migrationFileFromPath(path, cwd, id = basename(path, ".sql")) {
+    return {
+        id,
+        path,
+        relativePath: relative(cwd, path),
+    };
+}
+function maskSql(sql) {
+    return sql
+        .replace(/--[^\n\r]*/gu, blank)
+        .replace(/\/\*[\s\S]*?\*\//gu, blank)
+        .replace(/\$([A-Za-z_][A-Za-z0-9_]*)?\$[\s\S]*?\$\1\$/gu, blank)
+        .replace(/'(?:''|[^'])*'/gu, blank);
+}
+function blank(match) {
+    return match.replace(/[^\n\r]/gu, " ");
+}
+function normalizeIdentifier(identifier) {
+    return ((identifier ?? "")
+        .split(".")
+        .map((part) => part.trim().replace(/^"|"$/gu, "").toLowerCase())
+        .at(-1) ?? "");
+}
+function riskForMatch(sql, match, code, reason) {
+    return {
+        code,
+        line: lineForIndex(sql, match.index ?? 0),
+        match: sql.slice(match.index ?? 0, (match.index ?? 0) + match[0].length),
+        reason,
+    };
+}
+function lineForIndex(value, index) {
+    let line = 1;
+    for (let offset = 0; offset < index; offset += 1) {
+        if (value[offset] === "\n") {
+            line += 1;
+        }
+    }
+    return line;
+}

package/dist/deploy/pending-migrations.d.ts

@@ -0,0 +1,5 @@
+import type { CoreframeDatabaseClient, CoreframeDatabaseDialect } from "../db/client.ts";
+import type { MigrationFile } from "./migrations.ts";
+export declare function filterPendingMigrations(migrations: MigrationFile[], appliedNames: Iterable<string>): MigrationFile[];
+export declare function readAppliedMigrationNames(database: CoreframeDatabaseClient): Promise<Set<string>>;
+export declare function appliedMigrationsQuery(dialect: CoreframeDatabaseDialect): "select name from drizzle.__drizzle_migrations where name is not null" | "select name from __drizzle_migrations where name is not null";

package/dist/deploy/pending-migrations.js

@@ -0,0 +1,30 @@
+export function filterPendingMigrations(migrations, appliedNames) {
+    const applied = new Set(appliedNames);
+    return migrations.filter((migration) => !applied.has(migration.id));
+}
+export async function readAppliedMigrationNames(database) {
+    try {
+        const result = await database.execute(appliedMigrationsQuery(database.dialect));
+        return new Set(result.rows.flatMap((row) => (row.name ? [row.name] : [])));
+    }
+    catch (error) {
+        if (isMissingMigrationTableError(error)) {
+            return new Set();
+        }
+        throw error;
+    }
+}
+export function appliedMigrationsQuery(dialect) {
+    switch (dialect) {
+        case "postgres":
+            return "select name from drizzle.__drizzle_migrations where name is not null";
+        case "sqlite":
+            return "select name from __drizzle_migrations where name is not null";
+    }
+}
+function isMissingMigrationTableError(error) {
+    return (error instanceof Error &&
+        (("code" in error && (error.code === "42P01" || error.code === "3F000")) ||
+            error.message.includes("no such table") ||
+            error.message.includes("no such schema")));
+}

package/dist/deploy/tauri-release.d.ts

@@ -0,0 +1,85 @@
+import type { TauriReleaseConfig, TauriReleasePlatform } from "./config.ts";
+export type TauriReleaseArgs = {
+    tauriLocalPlatforms: TauriReleasePlatform[];
+    tauriWorkflowPlatforms: TauriReleasePlatform[];
+    tauriWorkflowName?: string;
+    tauriWorkflowRef?: string;
+};
+export type TauriReleasePlan = {
+    artifactDownloadDir: string;
+    b2ApplicationKey?: string;
+    b2ApplicationKeyId?: string;
+    b2Bucket?: string;
+    enabled: boolean;
+    latestManifestPath: string;
+    localPlatforms: TauriReleasePlatform[];
+    platform: Record<TauriReleasePlatform, ResolvedTauriReleasePlatformConfig>;
+    publicBaseUrl?: string;
+    publicPathPrefix: string;
+    releaseNotesPath?: string;
+    releasePath: string;
+    releaseUploadDir: string;
+    signingPrivateKey?: string;
+    workflowName: string;
+    workflowPlatforms: TauriReleasePlatform[];
+    workflowPollIntervalMs: number;
+    workflowRef?: string;
+    workflowTimeoutMs: number;
+};
+export type TauriReleaseMetadataSnapshot = {
+    files: {
+        path: string;
+        source: string;
+    }[];
+};
+export type PreparedTauriRelease = {
+    manifestPath: string;
+    uploadDir: string;
+};
+type ResolvedTauriReleasePlatformConfig = {
+    artifactGlobs: string[];
+    buildArgs: string[];
+    targetTriple: string;
+    updatePlatform: string;
+};
+type TauriUpdateManifest = {
+    notes?: string;
+    platforms: Record<string, {
+        signature: string;
+        url: string;
+    }>;
+    pub_date: string;
+    version: string;
+};
+export declare function parseTauriReleasePlatformList(value: string | undefined): ("macos" | "windows" | "linux" | "ios" | "android")[];
+export declare function parseTauriReleasePlatform(value: string): TauriReleasePlatform;
+export declare function resolveTauriReleasePlan({ args, config, env, }: {
+    args: TauriReleaseArgs;
+    config?: TauriReleaseConfig;
+    env: NodeJS.ProcessEnv;
+}): TauriReleasePlan;
+export declare function validateTauriReleasePlan(plan: TauriReleasePlan, cwd?: string): Promise<void>;
+export declare function writeTauriReleaseMetadata(plan: TauriReleasePlan, version: string, cwd?: string): Promise<TauriReleaseMetadataSnapshot>;
+export declare function restoreTauriReleaseMetadata(snapshot: TauriReleaseMetadataSnapshot): Promise<void>;
+export declare function prepareTauriRelease({ env, plan, releaseName, version, }: {
+    env: NodeJS.ProcessEnv;
+    plan: TauriReleasePlan;
+    releaseName: string;
+    version: string;
+}): Promise<PreparedTauriRelease | undefined>;
+export declare function uploadTauriReleaseToB2(plan: TauriReleasePlan, release: PreparedTauriRelease): Promise<void>;
+export declare function createTauriUpdateManifest({ artifacts, notes, pubDate, version, }: {
+    artifacts: {
+        signature: string;
+        updatePlatform: string;
+        url: string;
+    }[];
+    notes?: string;
+    pubDate?: Date;
+    version: string;
+}): TauriUpdateManifest;
+export declare function createTauriReleaseUpload({ plan, version, }: {
+    plan: TauriReleasePlan;
+    version: string;
+}): Promise<PreparedTauriRelease>;
+export {};