@coreframe/scripts 0.1.0 → 0.1.2

package/dist/db/migrate-held.js

@@ -1,119 +1,10 @@
 #!/usr/bin/env node
-import { createHash } from "node:crypto";
-import { readFile } from "node:fs/promises";
-import { collectHeldMigrationFiles, formatMigrationList } from "../deploy/migrations.js";
-import { createProjectDeployDatabase } from "./project.js";
-const CONFIRM_FLAG = "--confirm=run-held-migrations";
-const HELD_HEADER_FIELDS = ["-- Held migration:", "-- Safe after:", "-- Verification:"];
-export async function migrateHeldMigrations({ argv = process.argv.slice(2), database, env = process.env, } = {}) {
-    const migrations = await collectHeldMigrationFiles();
-    console.log("Held migration files:");
-    console.log(formatMigrationList(migrations));
-    if (!argv.includes(CONFIRM_FLAG)) {
-        throw new Error(`Held migrations require explicit confirmation. Re-run with ${CONFIRM_FLAG}.`);
-    }
-    if (migrations.length === 0) {
-        console.log("No held migrations to run.");
-        return;
-    }
-    const activeDatabase = database ?? (await createProjectDeployDatabase({ env }));
-    try {
-        await ensureHeldMigrationJournal(activeDatabase);
-        for (const migration of migrations) {
-            const sql = await readFile(migration.path, "utf8");
-            validateHeldMigrationHeader(sql, migration.relativePath);
-            const sha256 = hashSql(sql);
-            const applied = await activeDatabase.execute(heldMigrationSelectQuery(activeDatabase.dialect, migration.id));
-            if (applied.rows.length === 1) {
-                if (applied.rows[0]?.sha256 !== sha256) {
-                    throw new Error(`Held migration ${migration.relativePath} changed after it was applied.`);
-                }
-                console.log(`Skipping already-applied held migration ${migration.relativePath}`);
-                continue;
-            }
-            console.log(`Applying held migration ${migration.relativePath}`);
-            await runMigrationTransaction(activeDatabase, async (transactionDatabase) => {
-                await transactionDatabase.execute(sql);
-                await transactionDatabase.execute(heldMigrationInsertQuery(activeDatabase.dialect, migration.id, sha256));
-            });
-        }
-    }
-    finally {
-        if (!database) {
-            await activeDatabase.close?.();
-        }
-    }
-}
-export function validateHeldMigrationHeader(sql, relativePath) {
-    const missing = HELD_HEADER_FIELDS.filter((field) => !sql.includes(field));
-    if (missing.length > 0) {
-        throw new Error(`${relativePath} is missing held migration header fields: ${missing.join(", ")}`);
-    }
-}
-function hashSql(sql) {
-    return createHash("sha256").update(sql).digest("hex");
-}
-async function ensureHeldMigrationJournal(database) {
-    for (const statement of heldMigrationJournalStatements(database.dialect)) {
-        await database.execute(statement);
-    }
-}
-function heldMigrationJournalStatements(dialect) {
-    switch (dialect) {
-        case "postgres":
-            return [
-                "create schema if not exists drizzle",
-                `create table if not exists drizzle.__held_migrations (
+import{collectHeldMigrationFiles as e,formatMigrationList as t}from"../deploy/migrations.js";import{createProjectDeployDatabase as n}from"./project.js";import{readFile as r}from"node:fs/promises";import{createHash as i}from"node:crypto";const a=`--confirm=run-held-migrations`,o=[`-- Held migration:`,`-- Safe after:`,`-- Verification:`];async function s({argv:i=process.argv.slice(2),database:o,env:s=process.env}={}){let d=await e();if(console.log(`Held migration files:`),console.log(t(d)),!i.includes(a))throw Error(`Held migrations require explicit confirmation. Re-run with ${a}.`);if(d.length===0){console.log(`No held migrations to run.`);return}let m=o??await n({env:s});try{await u(m);for(let e of d){let t=await r(e.path,`utf8`);c(t,e.relativePath);let n=l(t),i=await m.execute(f(m.dialect,e.id));if(i.rows.length===1){if(i.rows[0]?.sha256!==n)throw Error(`Held migration ${e.relativePath} changed after it was applied.`);console.log(`Skipping already-applied held migration ${e.relativePath}`);continue}console.log(`Applying held migration ${e.relativePath}`),await h(m,async r=>{await r.execute(t),await r.execute(p(m.dialect,e.id,n))})}}finally{o||await m.close?.()}}function c(e,t){let n=o.filter(t=>!e.includes(t));if(n.length>0)throw Error(`${t} is missing held migration header fields: ${n.join(`, `)}`)}function l(e){return i(`sha256`).update(e).digest(`hex`)}async function u(e){for(let t of d(e.dialect))await e.execute(t)}function d(e){switch(e){case`postgres`:return[`create schema if not exists drizzle`,`create table if not exists drizzle.__held_migrations (
           id text primary key,
           sha256 text not null,
           applied_at timestamptz not null default now()
-        )`,
-            ];
-        case "sqlite":
-            return [
-                `create table if not exists __held_migrations (
+        )`];case`sqlite`:return[`create table if not exists __held_migrations (
           id text primary key,
           sha256 text not null,
           applied_at text not null default current_timestamp
-        )`,
-            ];
-    }
-}
-export function heldMigrationSelectQuery(dialect, id) {
-    return `select sha256 from ${heldMigrationJournalTable(dialect)} where id = ${sqlString(id)}`;
-}
-export function heldMigrationInsertQuery(dialect, id, sha256) {
-    return `insert into ${heldMigrationJournalTable(dialect)} (id, sha256) values (${sqlString(id)}, ${sqlString(sha256)})`;
-}
-function heldMigrationJournalTable(dialect) {
-    switch (dialect) {
-        case "postgres":
-            return "drizzle.__held_migrations";
-        case "sqlite":
-            return "__held_migrations";
-    }
-}
-async function runMigrationTransaction(database, run) {
-    if (database.transaction) {
-        await database.transaction(run);
-        return;
-    }
-    await database.execute("begin");
-    try {
-        await run(database);
-        await database.execute("commit");
-    }
-    catch (error) {
-        await database.execute("rollback");
-        throw error;
-    }
-}
-function sqlString(value) {
-    return `'${value.replaceAll("'", "''")}'`;
-}
-if (import.meta.main) {
-    migrateHeldMigrations().catch((error) => {
-        console.error(error);
-        process.exit(1);
-    });
-}
+        )`]}}function f(e,t){return`select sha256 from ${m(e)} where id = ${g(t)}`}function p(e,t,n){return`insert into ${m(e)} (id, sha256) values (${g(t)}, ${g(n)})`}function m(e){switch(e){case`postgres`:return`drizzle.__held_migrations`;case`sqlite`:return`__held_migrations`}}async function h(e,t){if(e.transaction){await e.transaction(t);return}await e.execute(`begin`);try{await t(e),await e.execute(`commit`)}catch(t){throw await e.execute(`rollback`),t}}function g(e){return`'${e.replaceAll(`'`,`''`)}'`}import.meta.main&&s().catch(e=>{console.error(e),process.exit(1)});export{p as heldMigrationInsertQuery,f as heldMigrationSelectQuery,s as migrateHeldMigrations,c as validateHeldMigrationHeader};

package/dist/db/migrate.d.ts

@@ -1,2 +1,4 @@
-#!/usr/bin/env node
-export declare function migrateLocalDb(): Promise<void>;
+//#region db/migrate.d.ts
+declare function migrateLocalDb(): Promise<void>;
+//#endregion
+export { migrateLocalDb };

package/dist/db/migrate.js

@@ -1,25 +1,2 @@
 #!/usr/bin/env node
-import { access } from "node:fs/promises";
-import { resolve } from "node:path";
-import { migrate } from "drizzle-orm/pglite/migrator";
-import { importProjectModule } from "../project.js";
-import { LOCAL_DB_DIR, MIGRATIONS_FOLDER } from "./config.js";
-const migrationsFolder = resolve(MIGRATIONS_FOLDER);
-export async function migrateLocalDb() {
-    await access(migrationsFolder);
-    const { createLocalDb } = await importProjectModule("src/db/local.ts");
-    const db = createLocalDb(LOCAL_DB_DIR);
-    try {
-        await migrate(db, { migrationsFolder });
-        console.log(`Applied local migrations from ${migrationsFolder}`);
-    }
-    finally {
-        await db.$client.close();
-    }
-}
-if (import.meta.main) {
-    migrateLocalDb().catch((error) => {
-        console.error(error);
-        process.exit(1);
-    });
-}
+import{importProjectModule as e}from"../project.js";import{LOCAL_DB_DIR as t,MIGRATIONS_FOLDER as n}from"./config.js";import{access as r}from"node:fs/promises";import{resolve as i}from"node:path";import{migrate as a}from"drizzle-orm/pglite/migrator";const o=i(n);async function s(){await r(o);let{createLocalDb:n}=await e(`src/db/local.ts`),i=n(t);try{await a(i,{migrationsFolder:o}),console.log(`Applied local migrations from ${o}`)}finally{await i.$client.close()}}import.meta.main&&s().catch(e=>{console.error(e),process.exit(1)});export{s as migrateLocalDb};

package/dist/db/project.d.ts

@@ -1,8 +1,20 @@
-import type { CoreframeDatabaseClient } from "./client.ts";
-export type CreateProjectDatabaseOptions = {
-    env?: NodeJS.ProcessEnv;
+import { DatabaseClient } from "./client.js";
+import { DatabaseConfig } from "../config.js";
+import { importProjectModule } from "../project.js";
+
+//#region db/project.d.ts
+type CreateProjectDatabaseOptions = {
+  config?: DatabaseConfig;
+  env?: NodeJS.ProcessEnv;
+  importProjectDependency?: ImportProjectDependency;
+  importProjectModule?: typeof importProjectModule;
 };
-export type ProjectDatabaseModule = {
-    createDeployDatabase?(options?: CreateProjectDatabaseOptions): CoreframeDatabaseClient | Promise<CoreframeDatabaseClient>;
-};
-export declare function createProjectDeployDatabase(options?: CreateProjectDatabaseOptions): Promise<CoreframeDatabaseClient>;
+type ImportProjectDependency = <T>(specifier: string) => Promise<T>;
+declare function createProjectDeployDatabase({
+  config,
+  env,
+  importProjectDependency,
+  importProjectModule: importModule
+}?: CreateProjectDatabaseOptions): Promise<DatabaseClient>;
+//#endregion
+export { CreateProjectDatabaseOptions, createProjectDeployDatabase };

package/dist/db/project.js

@@ -1,9 +1 @@
-import { importProjectModule } from "../project.js";
-const projectDatabaseConfigPath = "scripts/coreframe.db.ts";
-export async function createProjectDeployDatabase(options = {}) {
-    const module = await importProjectModule(projectDatabaseConfigPath);
-    if (!module.createDeployDatabase) {
-        throw new Error(`${projectDatabaseConfigPath} must export createDeployDatabase() for Coreframe database workflows.`);
-    }
-    return module.createDeployDatabase(options);
-}
+import{readProjectConfig as e}from"../config.js";import{importProjectModule as t}from"../project.js";import{createDatabaseAdapter as n}from"./client.js";import{createRequire as r}from"node:module";import{resolve as i}from"node:path";import{pathToFileURL as a}from"node:url";const o=`src/db/relations.ts`;async function s({config:n,env:r=process.env,importProjectDependency:i=u,importProjectModule:a=t}={}){let o=(n??(await e()).database)?.dialect??`postgres`;if(o===`postgres`)return c({env:r,importModule:a,importProjectDependency:i});if(o===`sqlite`)return l({env:r,importModule:a,importProjectDependency:i});throw Error(`Unsupported database dialect "${o}".`)}async function c({env:e,importModule:t,importProjectDependency:r}){let i=e.DATABASE_URL;if(!i)throw Error(`DATABASE_URL is required to create the deploy database.`);let[{drizzle:a},{relations:s}]=await Promise.all([r(`drizzle-orm/node-postgres`),t(o)]),c=a({connection:{connectionString:i,max:1},relations:s});return n({database:c,dialect:`postgres`,close:()=>c.$client?.end?.()??Promise.resolve()})}async function l({env:e,importModule:t,importProjectDependency:r}){let i=e.TURSO_DATABASE_URL??e.DATABASE_URL;if(!i)throw Error(`TURSO_DATABASE_URL or DATABASE_URL is required to create the deploy database.`);let[{createClient:a},{drizzle:s},{relations:c}]=await Promise.all([r(`@libsql/client`),r(`drizzle-orm/libsql`),t(o)]),l=a({url:i,authToken:e.TURSO_AUTH_TOKEN});return n({database:s({client:l,relations:c}),dialect:`sqlite`,close:async()=>{await l.close?.()}})}async function u(e){return await import(a(r(i(`package.json`)).resolve(e)).href)}export{s as createProjectDeployDatabase};

package/dist/db/reset.d.ts

@@ -1,2 +1,4 @@
-#!/usr/bin/env node
-export declare function resetLocalDb(): Promise<void>;
+//#region db/reset.d.ts
+declare function resetLocalDb(): Promise<void>;
+//#endregion
+export { resetLocalDb };

package/dist/db/reset.js

@@ -1,19 +1,2 @@
 #!/usr/bin/env node
-import { rm } from "node:fs/promises";
-import { relative, resolve } from "node:path";
-import { LOCAL_DB_DIR } from "./config.js";
-export async function resetLocalDb() {
-    const dataDir = resolve(LOCAL_DB_DIR);
-    const relativeDataDir = relative(process.cwd(), dataDir);
-    if (relativeDataDir === "" || relativeDataDir.startsWith("..")) {
-        throw new Error(`Refusing to reset local database outside the project: ${dataDir}`);
-    }
-    await rm(dataDir, { force: true, recursive: true });
-    console.log(`Removed local PGlite data at ${dataDir}`);
-}
-if (import.meta.main) {
-    resetLocalDb().catch((error) => {
-        console.error(error);
-        process.exit(1);
-    });
-}
+import{LOCAL_DB_DIR as e}from"./config.js";import{rm as t}from"node:fs/promises";import{relative as n,resolve as r}from"node:path";async function i(){let i=r(e),a=n(process.cwd(),i);if(a===``||a.startsWith(`..`))throw Error(`Refusing to reset local database outside the project: ${i}`);await t(i,{force:!0,recursive:!0}),console.log(`Removed local PGlite data at ${i}`)}import.meta.main&&i().catch(e=>{console.error(e),process.exit(1)});export{i as resetLocalDb};

package/dist/db/schema-push.d.ts

@@ -0,0 +1,22 @@
+import { DatabaseDialect } from "./client.js";
+
+//#region db/schema-push.d.ts
+type SchemaPushPlan = {
+  sqlStatements: string[];
+  hints: Array<{
+    hint: string;
+    statement?: string;
+  }>;
+  apply(): Promise<void>;
+};
+type SchemaPushModule = {
+  pushSchema(schema: Record<string, unknown>, db: never, migrationsConfig?: {
+    table?: string;
+    schema?: string;
+  }): Promise<SchemaPushPlan>;
+};
+type ImportSchemaPushModule = (dialect: DatabaseDialect) => Promise<SchemaPushModule>;
+declare function planLocalSchemaPush(dialect: DatabaseDialect, schema: Record<string, unknown>, db: unknown, importModule?: ImportSchemaPushModule): Promise<SchemaPushPlan>;
+declare function inferSchemaDialect(schema: Record<string, unknown>): DatabaseDialect;
+//#endregion
+export { SchemaPushModule, SchemaPushPlan, inferSchemaDialect, planLocalSchemaPush };

package/dist/db/schema-push.js

@@ -0,0 +1 @@
+import{createRequire as e}from"node:module";import{resolve as t}from"node:path";import{pathToFileURL as n}from"node:url";import{is as r}from"drizzle-orm";import{PgMaterializedView as i,PgTable as a,PgView as o}from"drizzle-orm/pg-core";import{SQLiteTable as s,SQLiteView as c}from"drizzle-orm/sqlite-core";const l={postgres:`drizzle-kit/payload/postgres`,sqlite:`drizzle-kit/payload/sqlite`};async function u(e,t,n,r=f){let{pushSchema:i}=await r(e);return i(t,n)}function d(e){let t=!1,n=!1;for(let r of Object.values(e))t||=p(r),n||=m(r);if(t&&n)throw Error(`Local database schema mixes PostgreSQL and SQLite entities.`);if(t)return`postgres`;if(n)return`sqlite`;throw Error(`Could not infer local database dialect from src/db/schema.ts.`)}async function f(r){return await import(n(e(t(`package.json`)).resolve(l[r])).href)}function p(e){return r(e,a)||r(e,o)||r(e,i)}function m(e){return r(e,s)||r(e,c)}export{d as inferSchemaDialect,u as planLocalSchemaPush};

package/dist/db/seed.d.ts

@@ -1,3 +1,6 @@
-#!/usr/bin/env node
-import type { SeedProfile } from "./config.ts";
-export declare function seedLocalDb(profile?: SeedProfile): Promise<void>;
+import { SeedProfile } from "./config.js";
+
+//#region db/seed.d.ts
+declare function seedLocalDb(profile?: SeedProfile): Promise<void>;
+//#endregion
+export { seedLocalDb };

package/dist/db/seed.js

@@ -1,23 +1,2 @@
 #!/usr/bin/env node
-import { importProjectModule } from "../project.js";
-import { getSeedProfile, LOCAL_DB_DIR } from "./config.js";
-export async function seedLocalDb(profile = getSeedProfile()) {
-    const [{ createLocalDb }, { seedUsers }] = await Promise.all([
-        importProjectModule("src/db/local.ts"),
-        importProjectModule("scripts/db/seeds/users.ts"),
-    ]);
-    const db = createLocalDb(LOCAL_DB_DIR);
-    try {
-        await seedUsers(db, profile);
-        console.log(`Seeded local database with "${profile}" profile`);
-    }
-    finally {
-        await db.$client.close();
-    }
-}
-if (import.meta.main) {
-    seedLocalDb().catch((error) => {
-        console.error(error);
-        process.exit(1);
-    });
-}
+import{importProjectModule as e}from"../project.js";import{LOCAL_DB_DIR as t,getSeedProfile as n}from"./config.js";async function r(r=n()){let[{createLocalDb:i},{seedUsers:a}]=await Promise.all([e(`src/db/local.ts`),e(`scripts/db/seeds/users.ts`)]),o=i(t);try{await a(o,r),console.log(`Seeded local database with "${r}" profile`)}finally{await o.$client.close()}}import.meta.main&&r().catch(e=>{console.error(e),process.exit(1)});export{r as seedLocalDb};

package/dist/db/setup.d.ts

@@ -1,3 +1,6 @@
-#!/usr/bin/env node
-import type { SeedProfile } from "./config.ts";
-export declare function setupLocalDb(profile?: SeedProfile): Promise<void>;
+import { SeedProfile } from "./config.js";
+
+//#region db/setup.d.ts
+declare function setupLocalDb(profile?: SeedProfile): Promise<void>;
+//#endregion
+export { setupLocalDb };

package/dist/db/setup.js

@@ -1,15 +1,2 @@
 #!/usr/bin/env node
-import { migrateLocalDb } from "./migrate.js";
-import { resetLocalDb } from "./reset.js";
-import { seedLocalDb } from "./seed.js";
-export async function setupLocalDb(profile = "small") {
-    await resetLocalDb();
-    await migrateLocalDb();
-    await seedLocalDb(profile);
-}
-if (import.meta.main) {
-    setupLocalDb().catch((error) => {
-        console.error(error);
-        process.exit(1);
-    });
-}
+import{seedLocalDb as e}from"./seed.js";import{migrateLocalDb as t}from"./migrate.js";import{resetLocalDb as n}from"./reset.js";async function r(r=`small`){await n(),await t(),await e(r)}import.meta.main&&r().catch(e=>{console.error(e),process.exit(1)});export{r as setupLocalDb};

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

@@ -1,2 +1,4 @@
-#!/usr/bin/env node
-export declare function checkDeployMigrations(): Promise<void>;
+//#region deploy/check-migrations.d.ts
+declare function checkDeployMigrations(): Promise<void>;
+//#endregion
+export { checkDeployMigrations };

package/dist/deploy/check-migrations.js

@@ -1,18 +1,2 @@
 #!/usr/bin/env node
-import { collectDeployMigrationFiles, formatMigrationList, formatMigrationScanFailures, scanDeployMigrationFiles, } from "./migrations.js";
-export async function checkDeployMigrations() {
-    const migrations = await collectDeployMigrationFiles();
-    console.log("Deploy migration files:");
-    console.log(formatMigrationList(migrations));
-    const failures = await scanDeployMigrationFiles(migrations);
-    if (failures.length > 0) {
-        throw new Error(`Deploy migrations contain unsafe SQL. Move unsafe statements to held migrations.\n${formatMigrationScanFailures(failures)}`);
-    }
-    console.log("Deploy migrations passed safety checks.");
-}
-if (import.meta.main) {
-    checkDeployMigrations().catch((error) => {
-        console.error(error);
-        process.exit(1);
-    });
-}
+import{collectDeployMigrationFiles as e,formatMigrationList as t,formatMigrationScanFailures as n,scanDeployMigrationFiles as r}from"./migrations.js";async function i(){let i=await e();console.log(`Deploy migration files:`),console.log(t(i));let a=await r(i);if(a.length>0)throw Error(`Deploy migrations contain unsafe SQL. Move unsafe statements to held migrations.\n${n(a)}`);console.log(`Deploy migrations passed safety checks.`)}import.meta.main&&i().catch(e=>{console.error(e),process.exit(1)});export{i as checkDeployMigrations};

package/dist/deploy/checks.d.ts

@@ -1,2 +1,6 @@
-import type { DeployContext, ResolvedDeployConfig } from "./config.ts";
-export declare function runPostDeployChecks(config: ResolvedDeployConfig, context: DeployContext): Promise<void>;
+import { DeployContext, ResolvedDeployConfig } from "./config.js";
+
+//#region deploy/checks.d.ts
+declare function runPostDeployChecks(config: ResolvedDeployConfig, context: DeployContext): Promise<void>;
+//#endregion
+export { runPostDeployChecks };

package/dist/deploy/checks.js

@@ -1,27 +1 @@
-export async function runPostDeployChecks(config, context) {
-    const productionUrl = context.productionUrl ?? config.productionUrl;
-    if (config.smokeChecks.length > 0 && !productionUrl) {
-        console.log("Skipping HTTP smoke checks. Set DEPLOY_URL or productionUrl in deploy config.");
-    }
-    for (const check of config.smokeChecks) {
-        if (!productionUrl && !check.url) {
-            continue;
-        }
-        const url = check.url ?? new URL(check.path ?? "/", productionUrl).toString();
-        const response = await fetch(url);
-        if (!statusMatches(response.status, check.expectedStatus ?? "2xx")) {
-            throw new Error(`${check.name} smoke check failed: ${url} returned ${response.status}.`);
-        }
-        console.log(`${check.name} smoke check passed: ${response.status} ${url}`);
-    }
-    await config.afterDeploy?.({ ...context, productionUrl });
-}
-function statusMatches(status, expected) {
-    if (expected === "2xx") {
-        return status >= 200 && status < 300;
-    }
-    if (Array.isArray(expected)) {
-        return expected.includes(status);
-    }
-    return status === expected;
-}
+async function e(e,n){let r=n.productionUrl??e.productionUrl;e.smokeChecks.length>0&&!r&&console.log(`Skipping HTTP smoke checks. Set DEPLOY_URL or productionUrl in deploy config.`);for(let n of e.smokeChecks){if(!r&&!n.url)continue;let e=n.url??new URL(n.path??`/`,r).toString(),i=await fetch(e);if(!t(i.status,n.expectedStatus??`2xx`))throw Error(`${n.name} smoke check failed: ${e} returned ${i.status}.`);console.log(`${n.name} smoke check passed: ${i.status} ${e}`)}await e.afterDeploy?.({...n,productionUrl:r})}function t(e,t){return t===`2xx`?e>=200&&e<300:Array.isArray(t)?t.includes(e):e===t}export{e as runPostDeployChecks};

package/dist/deploy/config.d.ts

@@ -1,50 +1,53 @@
-export type DeployContext = {
-    environment: string;
-    productionUrl?: string;
-    releaseName: string;
-    version: string;
+//#region deploy/config.d.ts
+type DeployContext = {
+  environment: string;
+  productionUrl?: string;
+  releaseName: string;
+  version: string;
 };
-export declare const tauriReleasePlatforms: readonly ["macos", "windows", "linux", "ios", "android"];
-export type TauriReleasePlatform = (typeof tauriReleasePlatforms)[number];
-export type TauriReleasePlatformConfig = {
-    artifactGlobs?: string[];
-    buildArgs?: string[];
-    targetTriple?: string;
-    updatePlatform?: string;
+declare const tauriReleasePlatforms: readonly ["macos", "windows", "linux", "ios", "android"];
+type TauriReleasePlatform = (typeof tauriReleasePlatforms)[number];
+type TauriReleasePlatformConfig = {
+  artifactGlobs?: string[];
+  buildArgs?: string[];
+  targetTriple?: string;
+  updatePlatform?: string;
 };
-export type TauriReleaseConfig = {
-    artifactDownloadDir?: string;
-    b2Bucket?: string;
-    latestManifestPath?: string;
-    localPlatforms?: TauriReleasePlatform[];
-    platform?: Partial<Record<TauriReleasePlatform, TauriReleasePlatformConfig>>;
-    publicBaseUrl?: string;
-    publicPathPrefix?: string;
-    releaseNotesPath?: string;
-    releasePath?: string;
-    releaseUploadDir?: string;
-    workflowPlatforms?: TauriReleasePlatform[];
-    workflowName?: string;
-    workflowPollIntervalMs?: number;
-    workflowRef?: string;
-    workflowTimeoutMs?: number;
+type TauriReleaseConfig = {
+  artifactDownloadDir?: string;
+  b2Bucket?: string;
+  latestManifestPath?: string;
+  localPlatforms?: TauriReleasePlatform[];
+  platform?: Partial<Record<TauriReleasePlatform, TauriReleasePlatformConfig>>;
+  publicBaseUrl?: string;
+  publicPathPrefix?: string;
+  releaseNotesPath?: string;
+  releasePath?: string;
+  releaseUploadDir?: string;
+  workflowPlatforms?: TauriReleasePlatform[];
+  workflowName?: string;
+  workflowPollIntervalMs?: number;
+  workflowRef?: string;
+  workflowTimeoutMs?: number;
 };
-export type DeploySmokeCheck = {
-    name: string;
-    path?: string;
-    url?: string;
-    expectedStatus?: "2xx" | number | number[];
+type DeploySmokeCheck = {
+  name: string;
+  path?: string;
+  url?: string;
+  expectedStatus?: "2xx" | number | number[];
 };
-export type DeployConfig = {
-    afterDeploy?: (context: DeployContext) => Promise<void> | void;
-    productionUrl?: string;
-    smokeChecks?: DeploySmokeCheck[];
-    tauriRelease?: TauriReleaseConfig;
+type DeployConfig = {
+  afterDeploy?: (context: DeployContext) => Promise<void> | void;
+  productionUrl?: string;
+  smokeChecks?: DeploySmokeCheck[];
+  tauriRelease?: TauriReleaseConfig;
 };
-export type ResolvedDeployConfig = {
-    afterDeploy?: (context: DeployContext) => Promise<void> | void;
-    productionUrl?: string;
-    smokeChecks: DeploySmokeCheck[];
-    tauriRelease: TauriReleaseConfig;
+type ResolvedDeployConfig = {
+  afterDeploy?: (context: DeployContext) => Promise<void> | void;
+  productionUrl?: string;
+  smokeChecks: DeploySmokeCheck[];
+  tauriRelease: TauriReleaseConfig;
 };
-export declare function resolveDeployConfig(config: DeployConfig, env?: NodeJS.ProcessEnv): ResolvedDeployConfig;
+declare function resolveDeployConfig(config: DeployConfig, env?: NodeJS.ProcessEnv): ResolvedDeployConfig;
+//#endregion
+export { DeployConfig, DeployContext, DeploySmokeCheck, ResolvedDeployConfig, TauriReleaseConfig, TauriReleasePlatform, TauriReleasePlatformConfig, resolveDeployConfig, tauriReleasePlatforms };

package/dist/deploy/config.js

@@ -1,9 +1 @@
-export const tauriReleasePlatforms = ["macos", "windows", "linux", "ios", "android"];
-export function resolveDeployConfig(config, env = process.env) {
-    return {
-        afterDeploy: config.afterDeploy,
-        productionUrl: config.productionUrl ?? env.DEPLOY_URL ?? env.PRODUCTION_URL,
-        smokeChecks: config.smokeChecks ?? [{ name: "home", path: "/" }],
-        tauriRelease: config.tauriRelease ?? {},
-    };
-}
+const e=[`macos`,`windows`,`linux`,`ios`,`android`];function t(e,t=process.env){return{afterDeploy:e.afterDeploy,productionUrl:e.productionUrl??t.DEPLOY_URL??t.PRODUCTION_URL,smokeChecks:e.smokeChecks??[{name:`home`,path:`/`}],tauriRelease:e.tauriRelease??{}}}export{t as resolveDeployConfig,e as tauriReleasePlatforms};

package/dist/deploy/migrations.d.ts

@@ -1,21 +1,24 @@
-export type MigrationFile = {
-    id: string;
-    path: string;
-    relativePath: string;
+//#region deploy/migrations.d.ts
+type MigrationFile = {
+  id: string;
+  path: string;
+  relativePath: string;
 };
-export type MigrationRisk = {
-    code: string;
-    line: number;
-    match: string;
-    reason: string;
+type MigrationRisk = {
+  code: string;
+  line: number;
+  match: string;
+  reason: string;
 };
-export type MigrationScanResult = {
-    migration: MigrationFile;
-    risks: MigrationRisk[];
+type MigrationScanResult = {
+  migration: MigrationFile;
+  risks: MigrationRisk[];
 };
-export declare function collectDeployMigrationFiles(cwd?: string): Promise<MigrationFile[]>;
-export declare function collectHeldMigrationFiles(cwd?: string): Promise<MigrationFile[]>;
-export declare function scanDeployMigrationFiles(migrations: MigrationFile[]): Promise<MigrationScanResult[]>;
-export declare function scanMigrationSql(sql: string): MigrationRisk[];
-export declare function formatMigrationScanFailures(results: MigrationScanResult[]): string;
-export declare function formatMigrationList(migrations: MigrationFile[]): string;
+declare function collectDeployMigrationFiles(cwd?: string): Promise<MigrationFile[]>;
+declare function collectHeldMigrationFiles(cwd?: string): Promise<MigrationFile[]>;
+declare function scanDeployMigrationFiles(migrations: MigrationFile[]): Promise<MigrationScanResult[]>;
+declare function scanMigrationSql(sql: string): MigrationRisk[];
+declare function formatMigrationScanFailures(results: MigrationScanResult[]): string;
+declare function formatMigrationList(migrations: MigrationFile[]): string;
+//#endregion
+export { MigrationFile, MigrationRisk, MigrationScanResult, collectDeployMigrationFiles, collectHeldMigrationFiles, formatMigrationList, formatMigrationScanFailures, scanDeployMigrationFiles, scanMigrationSql };