@coreframe/scripts 0.1.49 → 0.2.0

package/dist/db/local-postgres.d.ts

@@ -1,65 +0,0 @@
-import { DrizzleExecutor } from "./client.js";
-import { CoreframeConfig } from "../config.js";
-import { createProjectPostgresDrizzleDatabase } from "./project.js";
-import { LocalPostgresEnv, PostgresOutputTarget } from "local-postgres";
-
-//#region db/local-postgres.d.ts
-declare const LOCAL_POSTGRES_ENV_FLAG = "COREFRAME_LOCAL_POSTGRES";
-type LocalPostgresDb = Awaited<ReturnType<typeof createProjectPostgresDrizzleDatabase>> & {
-  $client: {
-    end(): Promise<void>;
-  };
-  transaction<Result>(run: (database: DrizzleExecutor) => Promise<Result>): Promise<Result>;
-  select(selection: Record<string, unknown>): {
-    from(table: unknown): {
-      where(condition: unknown): {
-        limit(count: number): Promise<Array<{
-          id: string;
-        }>>;
-      };
-    };
-  };
-};
-type LocalPostgresOptions = {
-  env?: NodeJS.ProcessEnv;
-};
-type ProjectPostgresSidecar = {
-  env: NodeJS.ProcessEnv;
-  [Symbol.asyncDispose](): Promise<void>;
-};
-type StartProjectPostgresOptions = {
-  config?: CoreframeConfig;
-  cwd?: string;
-  env?: NodeJS.ProcessEnv;
-  failIfRunning?: boolean;
-  postgresOutput?: PostgresOutputTarget;
-};
-type StartTemporaryProjectPostgresOptions = StartProjectPostgresOptions;
-declare class ProjectPostgresAlreadyRunningError extends Error {
-  readonly dataDir: string;
-  readonly pid: number;
-  constructor(dataDir: string, pid: number, options?: ErrorOptions);
-}
-declare function startProjectPostgres({
-  config,
-  cwd,
-  env,
-  failIfRunning,
-  postgresOutput
-}?: StartProjectPostgresOptions): Promise<ProjectPostgresSidecar>;
-declare function stopProjectPostgres({
-  dataDir,
-  pid
-}: ProjectPostgresAlreadyRunningError): Promise<void>;
-declare function startTemporaryProjectPostgres({
-  config,
-  cwd,
-  env
-}?: StartTemporaryProjectPostgresOptions): Promise<ProjectPostgresSidecar>;
-declare function createLocalPostgresEnv(env: NodeJS.ProcessEnv, postgresEnv: LocalPostgresEnv): NodeJS.ProcessEnv;
-declare function createLocalPostgresDb({
-  env
-}?: LocalPostgresOptions): Promise<LocalPostgresDb>;
-declare function getLocalPostgresConnectionString(env?: NodeJS.ProcessEnv): string;
-//#endregion
-export { LOCAL_POSTGRES_ENV_FLAG, LocalPostgresDb, ProjectPostgresAlreadyRunningError, ProjectPostgresSidecar, StartProjectPostgresOptions, StartTemporaryProjectPostgresOptions, createLocalPostgresDb, createLocalPostgresEnv, getLocalPostgresConnectionString, startProjectPostgres, startTemporaryProjectPostgres, stopProjectPostgres };

package/dist/db/local-postgres.js

@@ -1 +0,0 @@
-import{readProjectConfig as e}from"../config.js";import{fs as t,os as n}from"../environment.js";import{createProjectPostgresDrizzleDatabase as r}from"./project.js";import i from"node:path";import{startPostgres as a}from"local-postgres";import{PostgresDataDirInUseError as o,stopPostgresDataDir as s}from"local-postgres/core";const c=`COREFRAME_LOCAL_POSTGRES`,l=`coreframe`,u=2e3,d=4e3,f=new Map,p={name:`coreframe`,password:`coreframe`};var m=class extends Error{dataDir;pid;constructor(e,t,n){super(`PostgreSQL is already running for this project (PID ${t}). Stop the other top-level \`coreframe dev\` process before starting another.`,n),this.name=`ProjectPostgresAlreadyRunningError`,this.dataDir=e,this.pid=t}};async function h({config:n,cwd:r=process.cwd(),env:o=process.env,failIfRunning:s=!1,postgresOutput:c}={}){if(o.COREFRAME_LOCAL_POSTGRES===`1`||((n??await e({cwd:r})).database?.dialect??`postgres`)!==`postgres`)return w(o);let d=i.resolve(r,`.coreframe/postgres`),f=await T(d);if(f){if(s)throw new m(d,f.pid);return w(E(o,d,f))}let h=i.join(d,`postgres.log`);await t.rm(h,{force:!0});let g;try{g=await a({dataDir:d,database:l,postgresOutput:c??{filePath:h},postgres:{strategy:`prefer-local`},stopTimeoutMs:u,superuser:p})}catch(e){throw await D(e,c?void 0:h)}return b(o,g)}async function g({dataDir:e,pid:t}){let n=`${e}\0${t}`,r=f.get(n);if(r){await r;return}let i=S(e,t);f.set(n,i);try{await i}finally{f.get(n)===i&&f.delete(n)}}async function _({config:r,cwd:o=process.cwd(),env:s=process.env}={}){let c=(r??await e({cwd:o})).database?.dialect??`postgres`;if(c!==`postgres`)throw Error(`Temporary schema push checks require PostgreSQL, but this project uses ${c}.`);let d=await t.mkdtemp(i.join(n.tmpdir(),`coreframe-schema-check-`));try{let e=b(s,await a({dataDir:d,database:l,postgresOutput:`ignore`,postgres:{strategy:`prefer-local`},stopTimeoutMs:u,superuser:p}));return{env:e.env,async[Symbol.asyncDispose](){await e[Symbol.asyncDispose](),await t.rm(d,{force:!0,recursive:!0})}}}catch(e){throw await C(d,e),e}}function v(e,t){return{...e,...t,[c]:`1`}}async function y({env:e=process.env}={}){let t=k(e);return r({env:{...e,DATABASE_URL:t}})}function b(e,t){let n;return{env:v(e,t.env),async[Symbol.asyncDispose](){n??=x(t),await n}}}async function x(e){let t;try{await e[Symbol.asyncDispose]()}catch(e){t=e}if(e.pid===void 0){if(t)throw t;return}try{await s({dataDir:e.dataDir,expectedPid:e.pid,mode:`immediate`,timeoutMs:d})}catch(n){throw t?AggregateError([t,n],`Failed to stop PostgreSQL process ${e.pid}.`):n}}async function S(e,t){try{await s({dataDir:e,expectedPid:t,mode:`fast`,timeoutMs:d})}catch(n){try{await s({dataDir:e,expectedPid:t,mode:`immediate`,timeoutMs:d})}catch(e){throw AggregateError([n,e],`Failed to stop PostgreSQL process ${t}.`)}}}async function C(e,n){try{await s({dataDir:e,mode:`immediate`,timeoutMs:d})}catch(t){throw AggregateError([n,t],`Temporary PostgreSQL failed to start and could not be stopped for ${e}.`)}await t.rm(e,{force:!0,recursive:!0})}function w(e){return{env:e,async[Symbol.asyncDispose](){}}}async function T(e){let r;try{r=await t.readFile(i.join(e,`postmaster.pid`),`utf8`)}catch{return}let[a,,,o,,s]=r.split(/\r?\n/),c=Number(a);if(!Number.isSafeInteger(c)||c<=0)return;try{n.kill(c,0)}catch(e){if(!O(e)||e.code!==`EPERM`)return}let l=Number(o);if(!Number.isSafeInteger(l)||l<=0||l>65535||!s)throw Error(`Cannot read connection details for PostgreSQL process ${c} from ${e}.`);return{host:s,pid:c,port:l}}function E(e,t,{host:n,port:r}){let i=new URL(`postgresql://${n}:${r}/${l}`);return i.username=p.name,i.password=p.password,v(e,{DATABASE_URL:i.href,PGDATA:t,PGDATABASE:l,PGHOST:n,PGPASSWORD:p.password,PGPORT:String(r),PGUSER:p.name})}async function D(e,n){if(e instanceof o)return new m(e.dataDir,e.pid,{cause:e});let r=e instanceof Error?e.message:String(e),i;if(n)try{i=(await t.readFile(n,`utf8`)).trim()||void 0}catch{}let a=i?`\n\nPostgreSQL output:\n${i}`:``,s=n?`\n\nPostgreSQL log: ${n}`:``;return Error(`Local PostgreSQL failed to start: ${r}${a}${s}`,{cause:e})}function O(e){return e instanceof Error}function k(e=process.env){let t=e.DATABASE_URL||A(e);if(!t)throw Error(`DATABASE_URL or PGDATABASE, PGHOST, PGPORT, and PGUSER are required.`);return t}function A(e){let{PGDATABASE:t,PGHOST:n,PGPASSWORD:r,PGPORT:i,PGUSER:a}=e;if(!t||!n||!i||!a)return;let o=new URL(`postgresql://${n}:${i}/${t}`);return o.username=a,r&&(o.password=r),o.href}export{c as LOCAL_POSTGRES_ENV_FLAG,m as ProjectPostgresAlreadyRunningError,y as createLocalPostgresDb,v as createLocalPostgresEnv,k as getLocalPostgresConnectionString,h as startProjectPostgres,_ as startTemporaryProjectPostgres,g as stopProjectPostgres};

package/dist/db/migrate-held.d.ts

@@ -1,16 +0,0 @@
-import { DatabaseDialect } from "./client.js";
-
-//#region db/migrate-held.d.ts
-type MigrateHeldOptions = {
-  argv?: string[];
-  env?: NodeJS.ProcessEnv;
-};
-declare function migrateHeldMigrations({
-  argv,
-  env
-}?: MigrateHeldOptions): Promise<void>;
-declare function validateHeldMigrationHeader(sql: string, relativePath: string): void;
-declare function heldMigrationSelectQuery(dialect: DatabaseDialect, id: string): string;
-declare function heldMigrationInsertQuery(dialect: DatabaseDialect, id: string, sha256: string): string;
-//#endregion
-export { heldMigrationInsertQuery, heldMigrationSelectQuery, migrateHeldMigrations, validateHeldMigrationHeader };

package/dist/db/migrate-held.js

@@ -1,10 +0,0 @@
-#!/usr/bin/env node
-import{createProjectDeployDatabase as e}from"./project.js";import{collectHeldMigrationFiles as t,formatMigrationList as n}from"../deploy/migrations.js";import{createHash as r}from"node:crypto";import{readFile as i}from"node:fs/promises";const a=`--confirm=run-held-migrations`,o=[`-- Held migration:`,`-- Safe after:`,`-- Verification:`];async function s({argv:r=process.argv.slice(2),env:o=process.env}={}){let s=await t();if(console.log(`Held migration files:`),console.log(n(s)),!r.includes(a))throw Error(`Held migrations require explicit confirmation. Re-run with ${a}.`);if(s.length===0){console.log(`No held migrations to run.`);return}let d=await e({env:o});try{await u(d);for(let e of s){let t=await i(e.path,`utf8`);c(t,e.relativePath);let n=l(t),r=await d.execute(f(d.dialect,e.id));if(r.rows.length===1){if(r.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(d,async r=>{await r.execute(t),await r.execute(p(d.dialect,e.id,n))})}}finally{await d.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 r(`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 (
-          id text primary key,
-          sha256 text not null,
-          applied_at text not null default current_timestamp
-        )`]}}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(`'`,`''`)}'`}export{p as heldMigrationInsertQuery,f as heldMigrationSelectQuery,s as migrateHeldMigrations,c as validateHeldMigrationHeader};

package/dist/db/migrate.d.ts

@@ -1,9 +0,0 @@
-//#region db/migrate.d.ts
-type MigrateLocalDbOptions = {
-  env?: NodeJS.ProcessEnv;
-};
-declare function migrateLocalDb({
-  env
-}?: MigrateLocalDbOptions): Promise<void>;
-//#endregion
-export { migrateLocalDb };

package/dist/db/migrate.js

@@ -1,2 +0,0 @@
-#!/usr/bin/env node
-import{createLocalPostgresDb as e,startProjectPostgres as t}from"./local-postgres.js";import n from"../_virtual/_@oxc-project_runtime@0.138.0/helpers/esm/usingCtx.js";import{MIGRATIONS_FOLDER as r}from"./config.js";import{access as i}from"node:fs/promises";import{resolve as a}from"node:path";import{migrate as o}from"drizzle-orm/node-postgres/migrator";const s=a(r);async function c({env:r=process.env}={}){try{var a=n();await i(s);let c=await e({env:a.a(await t({env:r})).env});try{await o(c,{migrationsFolder:s}),console.log(`Applied local migrations from ${s}`)}finally{await c.$client.end()}}catch(e){a.e=e}finally{await a.d()}}export{c as migrateLocalDb};

package/dist/db/project.d.ts

@@ -1,23 +0,0 @@
-import { DatabaseClient, DrizzleExecutor } from "./client.js";
-import { DatabaseConfig } from "../config.js";
-
-//#region db/project.d.ts
-type CreateProjectDatabaseOptions = {
-  config?: DatabaseConfig;
-  env?: NodeJS.ProcessEnv;
-};
-type DrizzleDatabase = DrizzleExecutor & {
-  $client?: {
-    close?(): Promise<void> | void;
-    end?(): Promise<void>;
-  };
-};
-declare function createProjectDeployDatabase({
-  config,
-  env
-}?: CreateProjectDatabaseOptions): Promise<DatabaseClient>;
-declare function createProjectPostgresDrizzleDatabase({
-  env
-}?: CreateProjectDatabaseOptions): Promise<DrizzleDatabase>;
-//#endregion
-export { CreateProjectDatabaseOptions, createProjectDeployDatabase, createProjectPostgresDrizzleDatabase };

package/dist/db/project.js

@@ -1 +0,0 @@
-import{readProjectConfig as e}from"../config.js";import{importProjectDependency as t,importProjectModule as n}from"../project.js";import{createDatabaseAdapter as r}from"./client.js";const i=`src/db/relations.ts`;async function a({config:t,env:n=process.env}={}){let r=(t??(await e()).database)?.dialect??`postgres`;if(r===`postgres`)return s({env:n});if(r===`sqlite`)return c({env:n});throw Error(`Unsupported database dialect "${r}".`)}async function o({env:e=process.env}={}){let r=e.DATABASE_URL;if(!r)throw Error(`DATABASE_URL is required to create the PostgreSQL database.`);let[{drizzle:a},{relations:o}]=await Promise.all([t(`drizzle-orm/node-postgres`),n(i)]);return a({connection:{connectionString:r,max:1},relations:o})}async function s({env:e}){let t=await o({env:e});return r({database:t,dialect:`postgres`,close:()=>t.$client?.end?.()??Promise.resolve()})}async function c({env:e}){let a=e.TURSO_DATABASE_URL??e.DATABASE_URL;if(!a)throw Error(`TURSO_DATABASE_URL or DATABASE_URL is required to create the deploy database.`);let[{createClient:o},{drizzle:s},{relations:c}]=await Promise.all([t(`@libsql/client`),t(`drizzle-orm/libsql`),n(i)]),l=o({url:a,authToken:e.TURSO_AUTH_TOKEN});return r({database:s({client:l,relations:c}),dialect:`sqlite`,close:async()=>{await l.close?.()}})}export{a as createProjectDeployDatabase,o as createProjectPostgresDrizzleDatabase};

package/dist/db/reset.d.ts

@@ -1,9 +0,0 @@
-//#region db/reset.d.ts
-type ResetLocalDbOptions = {
-  env?: NodeJS.ProcessEnv;
-};
-declare function resetLocalDb({
-  env
-}?: ResetLocalDbOptions): Promise<void>;
-//#endregion
-export { resetLocalDb };

package/dist/db/reset.js

@@ -1,2 +0,0 @@
-#!/usr/bin/env node
-import{createLocalPostgresDb as e,startProjectPostgres as t}from"./local-postgres.js";import n from"../_virtual/_@oxc-project_runtime@0.138.0/helpers/esm/usingCtx.js";import{sql as r}from"drizzle-orm";async function i({env:i=process.env}={}){try{var a=n();let o=await e({env:a.a(await t({env:i})).env});try{await o.transaction(async e=>{await e.execute(r`drop schema if exists public cascade`),await e.execute(r`drop schema if exists drizzle cascade`),await e.execute(r`create schema public`)}),console.log(`Reset local PostgreSQL schema`)}finally{await o.$client.end()}}catch(e){a.e=e}finally{await a.d()}}export{i as resetLocalDb};

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

@@ -1,11 +0,0 @@
-//#region db/schema-check.d.ts
-type CheckSchemaPushOptions = {
-  env?: NodeJS.ProcessEnv;
-  seed?: boolean;
-};
-declare function checkSchemaPush({
-  env,
-  seed
-}?: CheckSchemaPushOptions): Promise<void>;
-//#endregion
-export { checkSchemaPush };

package/dist/db/schema-check.js

@@ -1,2 +0,0 @@
-#!/usr/bin/env node
-import{importProjectModule as e}from"../project.js";import{createLocalPostgresDb as t,startTemporaryProjectPostgres as n}from"./local-postgres.js";import r from"../_virtual/_@oxc-project_runtime@0.138.0/helpers/esm/usingCtx.js";import{inferSchemaDialect as i,planLocalSchemaPush as a}from"./schema-push.js";import{runProjectSeed as o}from"./seed.js";async function s({env:s=process.env,seed:l=!1}={}){try{var u=r();console.log(`Checking Drizzle schema against a throwaway PostgreSQL database`);let d=u.a(await n({env:s})),f=await e(`src/db/schema.ts`),p=await t({env:d.env});try{let e=i(f);if(e!==`postgres`)throw Error(`Temporary schema push checks require PostgreSQL schema, but found ${e}.`);let t=await a(e,f,p);t.sqlStatements.length===0?console.log(`Drizzle schema check passed with no changes`):(console.log(`Applying ${t.sqlStatements.length} statement(s) to throwaway database`),await t.apply(),console.log(`Drizzle schema check passed`)),l&&(console.log(`Seeding throwaway database`),await o(`default`,{env:d.env}),console.log(`Throwaway database seed check passed`))}finally{await c(p)}}catch(e){u.e=e}finally{await u.d()}}function c(e){return e.$client.end()}export{s as checkSchemaPush};

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

@@ -1,22 +0,0 @@
-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

@@ -1 +0,0 @@
-import{resolve as e}from"node:path";import{pathToFileURL as t}from"node:url";import{resolve as n}from"import-meta-resolve";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(l[r],t(e(`package.json`)).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,19 +0,0 @@
-import { SeedProfile } from "./config.js";
-
-//#region db/seed.d.ts
-type SeedLocalDbOptions = {
-  env?: NodeJS.ProcessEnv;
-};
-type RunProjectSeedOptions = {
-  env: NodeJS.ProcessEnv;
-  seedEntryPoint?: string;
-};
-declare function seedLocalDb(profile?: SeedProfile, {
-  env
-}?: SeedLocalDbOptions): Promise<void>;
-declare function runProjectSeed(profile: SeedProfile | undefined, {
-  env,
-  seedEntryPoint
-}: RunProjectSeedOptions): Promise<void>;
-//#endregion
-export { runProjectSeed, seedLocalDb };

package/dist/db/seed.js

@@ -1,2 +0,0 @@
-#!/usr/bin/env node
-import{readProjectConfig as e}from"../config.js";import{importProjectModule as t}from"../project.js";import{startProjectPostgres as n}from"./local-postgres.js";import r from"../_virtual/_@oxc-project_runtime@0.138.0/helpers/esm/usingCtx.js";import{getSeedProfile as i}from"./config.js";async function a(t=i(),{env:a=process.env}={}){try{var c=r();let i=await e(),l=s(i);await o(t,{env:c.a(await n({config:i,env:a})).env,seedEntryPoint:l}),console.log(`Seeded local database with "${t}" profile`)}catch(e){c.e=e}finally{await c.d()}}async function o(n=i(),{env:r,seedEntryPoint:a}){a??=s(await e()),await l(r,async()=>{await c(await t(a),a)({env:r,profile:n})})}function s(e){let t=e.database?.seed;if(!t)throw Error(`coreframe.config.ts must configure database.seed before running db seed.`);return t}function c(e,t){let n=e.default??e.seed??e.seedLocalDb;if(!n)throw Error(`${t} must export a default seed function, seed function, or seedLocalDb function.`);return n}async function l(e,t){let n=new Map;for(let[t,r]of Object.entries(e))n.set(t,process.env[t]),r===void 0?delete process.env[t]:process.env[t]=r;try{await t()}finally{for(let[e,t]of n)t===void 0?delete process.env[e]:process.env[e]=t}}export{o as runProjectSeed,a as seedLocalDb};

package/dist/db/setup.d.ts

@@ -1,11 +0,0 @@
-import { SeedProfile } from "./config.js";
-
-//#region db/setup.d.ts
-type SetupLocalDbOptions = {
-  env?: NodeJS.ProcessEnv;
-};
-declare function setupLocalDb(profile?: SeedProfile, {
-  env
-}?: SetupLocalDbOptions): Promise<void>;
-//#endregion
-export { setupLocalDb };

package/dist/db/setup.js

@@ -1,2 +0,0 @@
-#!/usr/bin/env node
-import{startProjectPostgres as e}from"./local-postgres.js";import t from"../_virtual/_@oxc-project_runtime@0.138.0/helpers/esm/usingCtx.js";import{seedLocalDb as n}from"./seed.js";import{migrateLocalDb as r}from"./migrate.js";import{resetLocalDb as i}from"./reset.js";async function a(a=`default`,{env:o=process.env}={}){try{var s=t();let c=s.a(await e({env:o})).env;await i({env:c}),await r({env:c}),await n(a,{env:c})}catch(e){s.e=e}finally{await s.d()}}export{a as setupLocalDb};

package/dist/deploy/access-token-secret.d.ts

@@ -1,39 +0,0 @@
-import { DeployEnvironment } from "./config.js";
-
-//#region deploy/access-token-secret.d.ts
-declare const accessTokenSigningSecretName = "COREFRAME_ACCESS_TOKEN_SECRET";
-type SecretNamesReader = (environment: DeployEnvironment, cwd: string) => Promise<readonly string[]>;
-type SecretWriter = (environment: DeployEnvironment, name: string, value: string, cwd: string) => Promise<void>;
-type AccessTokenSigningSecretOptions = {
-  cwd?: string;
-  environment: DeployEnvironment;
-  generateSecret?: () => string;
-  listSecretNames?: SecretNamesReader;
-};
-type PreparedAccessTokenSigningSecret = {
-  provisioned: boolean;
-  value?: string;
-};
-declare function prepareAccessTokenSigningSecret({
-  cwd,
-  environment,
-  generateSecret,
-  listSecretNames
-}: AccessTokenSigningSecretOptions): Promise<PreparedAccessTokenSigningSecret>;
-declare function verifyAccessTokenSigningSecret({
-  cwd,
-  environment,
-  listSecretNames
-}: Omit<AccessTokenSigningSecretOptions, "generateSecret">): Promise<void>;
-declare function rotateAccessTokenSigningSecret({
-  cwd,
-  environment,
-  generateSecret,
-  listSecretNames,
-  writeSecret
-}: AccessTokenSigningSecretOptions & {
-  writeSecret?: SecretWriter;
-}): Promise<void>;
-declare function generateAccessTokenSigningSecret(): string;
-//#endregion
-export { PreparedAccessTokenSigningSecret, accessTokenSigningSecretName, generateAccessTokenSigningSecret, prepareAccessTokenSigningSecret, rotateAccessTokenSigningSecret, verifyAccessTokenSigningSecret };

package/dist/deploy/access-token-secret.js

@@ -1 +0,0 @@
-import{randomBytes as e}from"node:crypto";import t,{SubprocessError as n}from"nano-spawn";const r=`COREFRAME_ACCESS_TOKEN_SECRET`;async function i({cwd:e=process.cwd(),environment:t,generateSecret:n=s,listSecretNames:i=c}){try{if((await i(t,e)).includes(`COREFRAME_ACCESS_TOKEN_SECRET`))return{provisioned:!1}}catch(e){if(!u(e))throw Error(`Could not inspect the ${t} Worker before provisioning ${r}. Refusing to risk replacing an existing signing secret.`,{cause:e})}return{provisioned:!0,value:n()}}async function a({cwd:e=process.cwd(),environment:t,listSecretNames:n=c}){if(!(await n(t,e)).includes(`COREFRAME_ACCESS_TOKEN_SECRET`))throw Error(`Cloudflare deployed the ${t} Worker without ${r}.`)}async function o({cwd:e=process.cwd(),environment:t,generateSecret:n=s,listSecretNames:i=c,writeSecret:o=l}){await o(t,r,n(),e),await a({cwd:e,environment:t,listSecretNames:i})}function s(){return e(32).toString(`base64url`)}async function c(e,n){let{stdout:r}=await t(`pnpm`,[`exec`,`wrangler`,`secret`,`list`,`--env`,e,`--format`,`json`],{cwd:n,stdin:`ignore`}),i=JSON.parse(r);if(!Array.isArray(i))throw Error(`Wrangler returned an invalid Worker secret list.`);return i.flatMap(e=>e&&typeof e==`object`&&`name`in e&&typeof e.name==`string`?[e.name]:[])}async function l(e,n,r,i){await t(`pnpm`,[`exec`,`wrangler`,`secret`,`put`,n,`--env`,e],{cwd:i,stdin:{string:r},stdout:`inherit`,stderr:`inherit`})}function u(e){return e instanceof n&&e.stderr.includes(`not found`)&&e.stderr.includes("If this is a new Worker, run `wrangler deploy` first")}export{r as accessTokenSigningSecretName,s as generateAccessTokenSigningSecret,i as prepareAccessTokenSigningSecret,o as rotateAccessTokenSigningSecret,a as verifyAccessTokenSigningSecret};

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

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

package/dist/deploy/check-migrations.js

@@ -1,2 +0,0 @@
-#!/usr/bin/env node
-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.`)}export{i as checkDeployMigrations};

package/dist/deploy/checks.d.ts

@@ -1,8 +0,0 @@
-import { DeployContext, ResolvedDeployConfig } from "./config.js";
-
-//#region deploy/checks.d.ts
-declare function runAfterWorkerDeploy(config: ResolvedDeployConfig, context: DeployContext): Promise<void>;
-declare function runPostDeployChecks(config: ResolvedDeployConfig, context: DeployContext): Promise<void>;
-declare function runDeploySmokeChecks(config: ResolvedDeployConfig, context: DeployContext, request?: typeof fetch, log?: (message: string) => void): Promise<void>;
-//#endregion
-export { runAfterWorkerDeploy, runDeploySmokeChecks, runPostDeployChecks };

package/dist/deploy/checks.js

@@ -1 +0,0 @@
-async function e(e,t){try{await e.afterWorkerDeploy?.(t)}catch(e){let t=e instanceof Error?e.message:String(e);throw Error(`Worker deployment succeeded, but deploy.afterWorkerDeploy failed: ${t}`,{cause:e})}}async function t(e,t){await n(e,t),await e.afterDeploy?.(t)}async function n(e,t,n=fetch,i=console.log){for(let a of e.smokeChecks){let e=a.url??new URL(a.path??`/`,t.url).toString(),o=await n(e);if(!r(o.status,a.expectedStatus??`2xx`))throw Error(`${a.name} smoke check failed: ${e} returned ${o.status}.`);i(`${a.name} smoke check passed: ${o.status} ${e}`)}}function r(e,t){return t===`2xx`?e>=200&&e<300:Array.isArray(t)?t.includes(e):e===t}export{e as runAfterWorkerDeploy,n as runDeploySmokeChecks,t as runPostDeployChecks};

package/dist/deploy/config.d.ts

@@ -1,68 +0,0 @@
-//#region deploy/config.d.ts
-declare const deployEnvironments: readonly ["staging", "production"];
-type DeployEnvironment = (typeof deployEnvironments)[number];
-type DeployContext = {
-  environment: DeployEnvironment;
-  releaseName: string;
-  url: string;
-  version: 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;
-};
-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 DeploySmokeCheck = {
-  name: string;
-  path?: string;
-  url?: string;
-  expectedStatus?: "2xx" | number | number[];
-};
-type DeployEnvironmentConfig = {
-  url?: string;
-};
-type StagingHostnameConfig = {
-  managedLabelPrefix: string;
-  parentHostname: string;
-  workerService: string;
-};
-type DeployConfig = {
-  afterDeploy?: (context: DeployContext) => Promise<void> | void;
-  afterWorkerDeploy?: (context: DeployContext) => Promise<void> | void;
-  environments?: Partial<Record<DeployEnvironment, DeployEnvironmentConfig>>;
-  smokeChecks?: DeploySmokeCheck[];
-  stagingHostname?: StagingHostnameConfig;
-  tauriRelease?: TauriReleaseConfig;
-};
-type ResolvedDeployConfig = {
-  afterDeploy?: (context: DeployContext) => Promise<void> | void;
-  afterWorkerDeploy?: (context: DeployContext) => Promise<void> | void;
-  environment: DeployEnvironment;
-  smokeChecks: DeploySmokeCheck[];
-  stagingHostname?: StagingHostnameConfig;
-  tauriRelease: TauriReleaseConfig;
-  url?: string;
-};
-declare function resolveDeployConfig(config: DeployConfig, environment: DeployEnvironment, env?: NodeJS.ProcessEnv): ResolvedDeployConfig;
-//#endregion
-export { DeployConfig, DeployContext, DeployEnvironment, DeployEnvironmentConfig, DeploySmokeCheck, ResolvedDeployConfig, StagingHostnameConfig, TauriReleaseConfig, TauriReleasePlatform, TauriReleasePlatformConfig, deployEnvironments, resolveDeployConfig, tauriReleasePlatforms };

package/dist/deploy/config.js

@@ -1 +0,0 @@
-const e=[`staging`,`production`],t=[`macos`,`windows`,`linux`,`ios`,`android`];function n(e,t,n=process.env){return{afterDeploy:e.afterDeploy,afterWorkerDeploy:e.afterWorkerDeploy,environment:t,smokeChecks:e.smokeChecks??[{name:`home`,path:`/`}],stagingHostname:e.stagingHostname,tauriRelease:e.tauriRelease??{},url:n.DEPLOY_URL||(t===`staging`&&e.stagingHostname?void 0:e.environments?.[t]?.url)}}export{e as deployEnvironments,n as resolveDeployConfig,t as tauriReleasePlatforms};

package/dist/deploy/migrations.d.ts

@@ -1,24 +0,0 @@
-//#region deploy/migrations.d.ts
-type MigrationFile = {
-  id: string;
-  path: string;
-  relativePath: string;
-};
-type MigrationRisk = {
-  code: string;
-  line: number;
-  match: string;
-  reason: string;
-};
-type MigrationScanResult = {
-  migration: MigrationFile;
-  risks: MigrationRisk[];
-};
-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 };

package/dist/deploy/migrations.js

@@ -1,4 +0,0 @@
-import{HELD_MIGRATIONS_FOLDER as e,MIGRATIONS_FOLDER as t}from"../db/config.js";import{access as n,readFile as r,readdir as i}from"node:fs/promises";import{basename as a,join as o,relative as s,resolve as c}from"node:path";const l=[{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`}];async function u(e=process.cwd()){return _(c(e,t),e)}async function d(t=process.cwd()){return v(c(t,e),t)}async function f(e){return(await Promise.all(e.map(async e=>({migration:e,risks:p(await r(e.path,`utf8`))})))).filter(e=>e.risks.length>0)}function p(e){let t=S(e),n=g(t),r=[];for(let n of l)for(let i of t.matchAll(n.pattern))r.push(T(e,i,n.code,n.reason));for(let i of t.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))n.has(w(i.groups?.table))||r.push(T(e,i,`add-not-null-column`,`adds a required column to an existing table before a separate compatibility rollout`));for(let i of t.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))n.has(w(i.groups?.table))||r.push(T(e,i,`add-constraint`,`enforces a constraint on an existing table before a separate validation step`));for(let i of t.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))n.has(w(i.groups?.table))||r.push(T(e,i,`create-unique-index`,`adds uniqueness to existing data before a separate dedupe and validation step`));return r.sort((e,t)=>e.line-t.line||e.code.localeCompare(t.code))}function m(e){return e.flatMap(e=>e.risks.map(t=>`${e.migration.relativePath}:${t.line} ${t.code}: ${t.reason} (${t.match.trim()})`)).join(`
-`)}function h(e){return e.length===0?`No migration files found.`:e.map(e=>`- ${e.relativePath}`).join(`
-`)}function g(e){let t=new Set;for(let n of e.matchAll(/\bcreate\s+(?:temporary\s+|temp\s+)?table\s+(?:if\s+not\s+exists\s+)?(?<table>(?:"[^"]+"|\w+)(?:\s*\.\s*(?:"[^"]+"|\w+))?)/giu))t.add(w(n.groups?.table));return t}async function _(e,t){let n=await y(e),r=[];for(let i of n){let n=o(e,i.name);if(i.isDirectory()){let e=o(n,`migration.sql`);await b(e)&&r.push(x(e,t,i.name));continue}i.isFile()&&i.name.endsWith(`.sql`)&&r.push(x(n,t,i.name.replace(/\.sql$/u,``)))}return r.sort((e,t)=>e.id.localeCompare(t.id))}async function v(e,t){return(await y(e)).filter(e=>e.isFile()&&e.name.endsWith(`.sql`)).map(n=>x(o(e,n.name),t,n.name.replace(/\.sql$/u,``))).sort((e,t)=>e.id.localeCompare(t.id))}async function y(e){try{return await i(e,{withFileTypes:!0})}catch(e){if(e instanceof Error&&`code`in e&&e.code===`ENOENT`)return[];throw e}}async function b(e){try{return await n(e),!0}catch(e){if(e instanceof Error&&`code`in e&&e.code===`ENOENT`)return!1;throw e}}function x(e,t,n=a(e,`.sql`)){return{id:n,path:e,relativePath:s(t,e)}}function S(e){return e.replace(/--[^\n\r]*/gu,C).replace(/\/\*[\s\S]*?\*\//gu,C).replace(/\$([A-Za-z_][A-Za-z0-9_]*)?\$[\s\S]*?\$\1\$/gu,C).replace(/'(?:''|[^'])*'/gu,C)}function C(e){return e.replace(/[^\n\r]/gu,` `)}function w(e){return(e??``).split(`.`).map(e=>e.trim().replace(/^"|"$/gu,``).toLowerCase()).at(-1)??``}function T(e,t,n,r){return{code:n,line:E(e,t.index??0),match:e.slice(t.index??0,(t.index??0)+t[0].length),reason:r}}function E(e,t){let n=1;for(let r=0;r<t;r+=1)e[r]===`
-`&&(n+=1);return n}export{u as collectDeployMigrationFiles,d as collectHeldMigrationFiles,h as formatMigrationList,m as formatMigrationScanFailures,f as scanDeployMigrationFiles,p as scanMigrationSql};

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

@@ -1,9 +0,0 @@
-import { DatabaseClient, DatabaseDialect } from "../db/client.js";
-import { MigrationFile } from "./migrations.js";
-
-//#region deploy/pending-migrations.d.ts
-declare function filterPendingMigrations(migrations: MigrationFile[], appliedNames: Iterable<string>): MigrationFile[];
-declare function readAppliedMigrationNames(database: DatabaseClient): Promise<Set<string>>;
-declare function appliedMigrationsQuery(dialect: DatabaseDialect): "select name from drizzle.__drizzle_migrations where name is not null" | "select name from __drizzle_migrations where name is not null";
-//#endregion
-export { appliedMigrationsQuery, filterPendingMigrations, readAppliedMigrationNames };

package/dist/deploy/pending-migrations.js

@@ -1 +0,0 @@
-function e(e,t){let n=new Set(t);return e.filter(e=>!n.has(e.id))}async function t(e){try{let t=await e.execute(n(e.dialect));return new Set(t.rows.flatMap(e=>e.name?[e.name]:[]))}catch(e){if(r(e))return new Set;throw e}}function n(e){switch(e){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 r(e){return e instanceof Error&&(`code`in e&&(e.code===`42P01`||e.code===`3F000`)||e.message.includes(`no such table`)||e.message.includes(`no such schema`))}export{n as appliedMigrationsQuery,e as filterPendingMigrations,t as readAppliedMigrationNames};

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

@@ -1,106 +0,0 @@
-import { TauriReleaseConfig, TauriReleasePlatform } from "./config.js";
-
-//#region deploy/tauri-release.d.ts
-type TauriReleaseArgs = {
-  tauriLocalPlatforms: TauriReleasePlatform[];
-  tauriWorkflowPlatforms: TauriReleasePlatform[];
-  tauriWorkflowName?: string;
-  tauriWorkflowRef?: string;
-};
-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;
-};
-type TauriReleaseMetadataSnapshot = {
-  files: {
-    path: string;
-    source: string;
-  }[];
-};
-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;
-};
-declare function parseTauriReleasePlatformList(value: string | undefined): ("macos" | "windows" | "linux" | "ios" | "android")[];
-declare function parseTauriReleasePlatform(value: string): TauriReleasePlatform;
-declare function resolveTauriReleasePlan({
-  args,
-  config,
-  env
-}: {
-  args: TauriReleaseArgs;
-  config?: TauriReleaseConfig;
-  env: NodeJS.ProcessEnv;
-}): TauriReleasePlan;
-declare function validateTauriReleasePlan(plan: TauriReleasePlan, cwd?: string): Promise<void>;
-declare function validateTauriReleaseIdentifier(tauriConfigSource: string, tauriConfigPath?: string): string;
-declare function writeTauriReleaseMetadata(plan: TauriReleasePlan, version: string, cwd?: string): Promise<TauriReleaseMetadataSnapshot>;
-declare function restoreTauriReleaseMetadata(snapshot: TauriReleaseMetadataSnapshot): Promise<void>;
-declare function prepareTauriRelease({
-  env,
-  plan,
-  releaseName,
-  version
-}: {
-  env: NodeJS.ProcessEnv;
-  plan: TauriReleasePlan;
-  releaseName: string;
-  version: string;
-}): Promise<PreparedTauriRelease | undefined>;
-declare function uploadTauriReleaseToB2(plan: TauriReleasePlan, release: PreparedTauriRelease): Promise<void>;
-declare function createTauriUpdateManifest({
-  artifacts,
-  notes,
-  pubDate,
-  version
-}: {
-  artifacts: {
-    signature: string;
-    updatePlatform: string;
-    url: string;
-  }[];
-  notes?: string;
-  pubDate?: Date;
-  version: string;
-}): TauriUpdateManifest;
-declare function createTauriReleaseUpload({
-  plan,
-  version
-}: {
-  plan: TauriReleasePlan;
-  version: string;
-}): Promise<PreparedTauriRelease>;
-//#endregion
-export { PreparedTauriRelease, TauriReleaseArgs, TauriReleaseMetadataSnapshot, TauriReleasePlan, createTauriReleaseUpload, createTauriUpdateManifest, parseTauriReleasePlatform, parseTauriReleasePlatformList, prepareTauriRelease, resolveTauriReleasePlan, restoreTauriReleaseMetadata, uploadTauriReleaseToB2, validateTauriReleaseIdentifier, validateTauriReleasePlan, writeTauriReleaseMetadata };

package/dist/deploy/tauri-release.js

@@ -1 +0,0 @@
-import{tauriReleasePlatforms as e}from"./config.js";import{randomUUID as t}from"node:crypto";import{access as n,cp as r,mkdir as i,readFile as a,rm as o,stat as s,writeFile as c}from"node:fs/promises";import{basename as l,dirname as u,join as d,relative as f,resolve as p,sep as m}from"node:path";import h from"nano-spawn";import{constants as g}from"node:fs";import{setTimeout as _}from"node:timers/promises";import{glob as v}from"tinyglobby";const y={android:{artifactGlobs:[`src-tauri/target/**/*.sig`,`src-tauri/gen/android/**/*.sig`],buildArgs:[`tauri`,`android`,`build`,`--target`,`aarch64-linux-android`],targetTriple:`aarch64-linux-android`,updatePlatform:`android-aarch64`},ios:{artifactGlobs:[`src-tauri/target/**/*.sig`,`src-tauri/gen/apple/**/*.sig`],buildArgs:[`tauri`,`ios`,`build`,`--target`,`aarch64-apple-ios`],targetTriple:`aarch64-apple-ios`,updatePlatform:`ios-aarch64`},linux:{artifactGlobs:[`src-tauri/target/x86_64-unknown-linux-gnu/release/bundle/**/*.sig`,`src-tauri/target/release/bundle/**/*.sig`,`src-tauri/target/**/release/bundle/**/*.sig`],buildArgs:[`tauri`,`build`,`--target`,`x86_64-unknown-linux-gnu`,`--`,`--locked`],targetTriple:`x86_64-unknown-linux-gnu`,updatePlatform:`linux-x86_64`},macos:{artifactGlobs:[`src-tauri/target/aarch64-apple-darwin/release/bundle/**/*.sig`,`src-tauri/target/release/bundle/**/*.sig`,`src-tauri/target/**/release/bundle/**/*.sig`],buildArgs:[`tauri`,`build`,`--target`,`aarch64-apple-darwin`,`--`,`--locked`],targetTriple:`aarch64-apple-darwin`,updatePlatform:`darwin-aarch64`},windows:{artifactGlobs:[`src-tauri/target/x86_64-pc-windows-msvc/release/bundle/**/*.sig`,`src-tauri/target/release/bundle/**/*.sig`,`src-tauri/target/**/release/bundle/**/*.sig`],buildArgs:[`tauri`,`build`,`--target`,`x86_64-pc-windows-msvc`,`--`,`--locked`],targetTriple:`x86_64-pc-windows-msvc`,updatePlatform:`windows-x86_64`}};function b(e){return e?e.split(/[,\s]+/u).filter(Boolean).map(e=>x(e)):[]}function x(t){if(X(t))return t;throw Error(`Invalid Tauri release platform "${t}". Expected one of: ${e.join(`, `)}.`)}function S({args:e,config:t={},env:n}){let r=Y([...t.localPlatforms??[],...b(n.TAURI_RELEASE_LOCAL_PLATFORMS),...e.tauriLocalPlatforms]),i=Y([...t.workflowPlatforms??[],...b(n.TAURI_RELEASE_WORKFLOW_PLATFORMS),...e.tauriWorkflowPlatforms]),a=r.filter(e=>i.includes(e));if(a.length>0)throw Error(`Build each Tauri release platform either locally or through the workflow, not both: ${a.join(`, `)}.`);return{artifactDownloadDir:n.TAURI_RELEASE_ARTIFACT_DOWNLOAD_DIR??t.artifactDownloadDir??`.coreframe/tauri-artifacts`,b2ApplicationKey:n.B2_APPLICATION_KEY??n.B2_SECRET_ACCESS_KEY,b2ApplicationKeyId:n.B2_APPLICATION_KEY_ID??n.B2_KEY_ID??n.B2_ACCESS_KEY_ID,b2Bucket:t.b2Bucket??n.B2_BUCKET,enabled:r.length>0||i.length>0,latestManifestPath:n.TAURI_RELEASE_LATEST_MANIFEST_PATH??t.latestManifestPath??`latest.json`,localPlatforms:r,platform:L(t.platform,n),publicBaseUrl:t.publicBaseUrl??n.TAURI_RELEASE_PUBLIC_BASE_URL??n.UPDATE_PUBLIC_BASE_URL,publicPathPrefix:n.TAURI_RELEASE_PUBLIC_PATH_PREFIX??t.publicPathPrefix??n.UPDATE_PUBLIC_PATH_PREFIX??``,releaseNotesPath:n.TAURI_RELEASE_NOTES_FILE??t.releaseNotesPath,releasePath:n.TAURI_RELEASE_PATH??t.releasePath??"releases/${version}",releaseUploadDir:n.TAURI_RELEASE_UPLOAD_DIR??t.releaseUploadDir??`release-upload`,signingPrivateKey:n.TAURI_SIGNING_PRIVATE_KEY,workflowName:e.tauriWorkflowName??n.TAURI_RELEASE_WORKFLOW_NAME??t.workflowName??`tauri-release-artifacts.yml`,workflowPlatforms:i,workflowPollIntervalMs:J(n.TAURI_RELEASE_WORKFLOW_POLL_SECONDS,`TAURI_RELEASE_WORKFLOW_POLL_SECONDS`)*1e3||t.workflowPollIntervalMs||15e3,workflowRef:e.tauriWorkflowRef??n.TAURI_RELEASE_WORKFLOW_REF??t.workflowRef,workflowTimeoutMs:J(n.TAURI_RELEASE_WORKFLOW_TIMEOUT_MINUTES,`TAURI_RELEASE_WORKFLOW_TIMEOUT_MINUTES`)*6e4||t.workflowTimeoutMs||36e5}}async function C(e,t=process.cwd()){if(!e.enabled)return;let n=[[`TAURI_RELEASE_PUBLIC_BASE_URL`,e.publicBaseUrl],[`B2_APPLICATION_KEY_ID`,e.b2ApplicationKeyId],[`B2_APPLICATION_KEY`,e.b2ApplicationKey],[`B2_BUCKET`,e.b2Bucket]].flatMap(([e,t])=>t?[]:[e]);if(n.length>0)throw Error(`Missing required Tauri release configuration: ${n.join(`, `)}`);try{new URL(e.publicBaseUrl)}catch{throw Error(`Invalid TAURI_RELEASE_PUBLIC_BASE_URL: ${e.publicBaseUrl}`)}let r=d(t,`src-tauri/tauri.conf.json`);if(!await Z(r))throw Error(`Tauri release platforms were requested, but src-tauri/tauri.conf.json does not exist.`);if(w(await a(r,`utf8`),r),e.localPlatforms.length>0&&!e.signingPrivateKey)throw Error(`TAURI_SIGNING_PRIVATE_KEY is required for local Tauri release builds.`);e.workflowPlatforms.length>0&&await h(`gh`,[`workflow`,`view`,e.workflowName,`--ref`,e.workflowRef??await H()],{stdin:`ignore`}),await h(`b2`,[`version`],{stdin:`ignore`})}function w(e,t=`src-tauri/tauri.conf.json`){let n=JSON.parse(e).identifier;if(typeof n!=`string`||n===`com.example`||n.startsWith(`com.example.`))throw Error(`${t} must use an organization-owned reverse-domain identifier before building release artifacts.`);return n}async function T(e,t,n=process.cwd()){if(!e.enabled)return{files:[]};let r=d(n,`src-tauri/tauri.conf.json`),i=d(n,`src-tauri/Cargo.toml`),o=d(n,`src-tauri/Cargo.lock`),s=await a(r,`utf8`),l=await a(i,`utf8`),u=z(l,i),f=[{path:r,source:s},{path:i,source:l}],p=[],m=JSON.parse(s);if(m.version=t,m.bundle={...m.bundle??{},createUpdaterArtifacts:!0},p.push({path:r,source:`${JSON.stringify(m,null,2)}\n`}),p.push({path:i,source:B(l,u,t,i)}),await Z(o)){let e=await a(o,`utf8`);f.push({path:o,source:e}),p.push({path:o,source:V(e,u,t,o)})}for(let e of p)await c(e.path,e.source);return{files:f}}async function E(e){for(let t of e.files)await c(t.path,t.source)}async function D({env:e,plan:t,releaseName:n,version:r}){if(!t.enabled)return;await U(t.artifactDownloadDir),await U(t.releaseUploadDir);let i=t.workflowPlatforms.length>0?await j({plan:t,releaseName:n,version:r}):void 0;for(let n of t.localPlatforms)await P(n,t,e);if(i){let e=await M(t,i.runNameMarker);await h(`gh`,[`run`,`download`,String(e),`--dir`,t.artifactDownloadDir],{stdio:`inherit`})}return A({plan:t,version:r})}async function O(e,t){await h(`b2`,[`account`,`authorize`,e.b2ApplicationKeyId,e.b2ApplicationKey],{stdin:`ignore`});let n=(await v(`**/*`,{cwd:t.uploadDir,onlyFiles:!0})).sort((e,n)=>e===t.manifestPath?1:n===t.manifestPath?-1:e.localeCompare(n));for(let r of n)await h(`b2`,[`file`,`upload`,e.b2Bucket,d(t.uploadDir,r),r],{stdin:`ignore`}),console.log(`Uploaded ${r}`)}function k({artifacts:e,notes:t,pubDate:n=new Date,version:r}){return{...t?{notes:t}:{},platforms:Object.fromEntries(e.map(e=>[e.updatePlatform,{signature:e.signature,url:e.url}])),pub_date:n.toISOString(),version:r}}async function A({plan:e,version:t}){let n=q(e.publicPathPrefix,G(e.releasePath,t)),o=q(e.publicPathPrefix,e.latestManifestPath),s=[...e.localPlatforms,...e.workflowPlatforms],f=[];for(let o of s){let s=e.platform[o],c=e.localPlatforms.includes(o)?`.`:d(e.artifactDownloadDir,`tauri-${o}-${t}`),p=await F({globs:e.localPlatforms.includes(o)?s.artifactGlobs:[`**/*.sig`],sourceRoot:c,version:t}),m=q(n,s.updatePlatform),h=q(m,l(p.artifactPath)),g=q(m,l(p.signaturePath)),_=d(e.releaseUploadDir,...h.split(`/`)),v=d(e.releaseUploadDir,...g.split(`/`)),y=(await a(p.signaturePath,`utf8`)).trim();await i(u(_),{recursive:!0}),await r(p.artifactPath,_),await r(p.signaturePath,v),f.push({signature:y,updatePlatform:s.updatePlatform,url:K(e.publicBaseUrl,h)})}let p=k({artifacts:f,notes:e.releaseNotesPath?await a(e.releaseNotesPath,`utf8`):void 0,version:t}),m=d(e.releaseUploadDir,...o.split(`/`));return await i(u(m),{recursive:!0}),await c(m,`${JSON.stringify(p,null,2)}\n`),{manifestPath:o,uploadDir:e.releaseUploadDir}}async function j({plan:n,releaseName:r,version:i}){let a=n.workflowRef??await H(),o=`coreframe-${Date.now()}-${t().slice(0,8)}`;return await h(`gh`,[`workflow`,`run`,n.workflowName,`--ref`,a,`-f`,`release_name=${r}`,`-f`,`run_id=${o}`,`-f`,`version=${i}`,...e.flatMap(e=>[`-f`,`${e}=${n.workflowPlatforms.includes(e)?`true`:`false`}`])],{stdin:`ignore`}),{runNameMarker:o}}async function M(e,t){let n=Date.now()+e.workflowTimeoutMs;for(;Date.now()<n;){let n=await N(e,t);if(n?.status===`completed`){if(n.conclusion===`success`)return n.databaseId;throw Error(`Tauri release workflow ${n.databaseId} finished with ${n.conclusion}.`)}await _(e.workflowPollIntervalMs)}throw Error(`Timed out waiting for Tauri release workflow after ${Math.round(e.workflowTimeoutMs/6e4)} minutes.`)}async function N(e,t){let{stdout:n}=await h(`gh`,[`run`,`list`,`--workflow`,e.workflowName,`--event`,`workflow_dispatch`,`--json`,`conclusion,databaseId,displayTitle,status`,`--limit`,`50`],{stdin:`ignore`});return JSON.parse(n).find(e=>e.displayTitle.includes(t))}async function P(e,t,n){await h(`pnpm`,t.platform[e].buildArgs,{env:n,stdio:`inherit`})}async function F({globs:e,sourceRoot:t,version:n}){let r=await v(e,{cwd:t,absolute:!0,onlyFiles:!0}),i=[];for(let e of r){let t=e.replace(/\.sig$/u,``);await Q(t)&&i.push({artifactPath:t,signaturePath:e})}if(i.length===0)throw Error(`Could not find a Tauri updater artifact and .sig pair under ${t}.`);return i.sort((e,t)=>{let r=I(e.artifactPath,n);return I(t.artifactPath,n)-r||e.artifactPath.localeCompare(t.artifactPath)})[0]}function I(e,t){let n=0;return e.includes(t)&&(n+=100),/\.(app\.tar\.gz|AppImage\.tar\.gz|zip)$/u.test(e)&&(n+=10),/\.(exe|msi|dmg|AppImage|deb|rpm|apk|aab|ipa)$/u.test(e)&&(n+=5),n}function L(t={},n){return Object.fromEntries(e.map(e=>{let r=t[e]??{},i={...y[e],...r},a=n[`TAURI_RELEASE_${e.toUpperCase()}_TARGET_TRIPLE`],o=n[`TAURI_RELEASE_${e.toUpperCase()}_UPDATE_PLATFORM`],s=a??i.targetTriple,c=r.buildArgs?r.buildArgs:R(e,s);return[e,{...i,artifactGlobs:i.artifactGlobs??y[e].artifactGlobs,buildArgs:c,targetTriple:s,updatePlatform:o??i.updatePlatform}]}))}function R(e,t){return e===`android`?[`tauri`,`android`,`build`,`--target`,t]:e===`ios`?[`tauri`,`ios`,`build`,`--target`,t]:[`tauri`,`build`,`--target`,t,`--`,`--locked`]}function z(e,t){let n=/^\[package\][\s\S]*?^name = "(?<name>[^"]+)"/mu.exec(e);if(!n?.groups?.name)throw Error(`${t} is missing a [package] name.`);return n.groups.name}function B(e,t,n,r){let i=RegExp(`(^\\[package\\][\\s\\S]*?^name = "${$(t)}"[\\s\\S]*?^version = ")[^"]+(")`,`mu`),a=e.replace(i,`$1${n}$2`);if(a===e)throw Error(`${r} is missing a package version for ${t}.`);return a}function V(e,t,n,r){let i=RegExp(`(\\[\\[package\\]\\]\\nname = "${$(t)}"\\nversion = ")[^"]+(")`,`u`),a=e.replace(i,`$1${n}$2`);if(a===e)throw Error(`${r} is missing a package lock entry for ${t}.`);return a}async function H(){let{stdout:e}=await h(`git`,[`rev-parse`,`--abbrev-ref`,`HEAD`],{stdin:`ignore`}),t=e.trim();if(t!==`HEAD`)return t;let{stdout:n}=await h(`git`,[`rev-parse`,`HEAD`],{stdin:`ignore`});return n.trim()}async function U(e){W(e),await o(e,{force:!0,recursive:!0}),await i(e,{recursive:!0})}function W(e){let t=p(e),n=f(process.cwd(),t).split(m).join(`/`);if(n===``||n===`.`||n.startsWith(`../`)||n===`src-tauri`||n.startsWith(`src-tauri/`)||n===`tauri`||n.startsWith(`tauri/`))throw Error(`Refusing to reset unsafe Tauri release directory: ${e}`)}function G(e,t){return e.replaceAll("${version}",t)}function K(e,t){let n=new URL(e),r=q(n.pathname.replace(/\/+$/u,``),t);return n.pathname=r.startsWith(`/`)?r:`/${r}`,n.toString()}function q(...e){return e.flatMap(e=>e.split(`/`)).map(e=>e.trim()).filter(Boolean).join(`/`)}function J(e,t){if(!e)return 0;let n=Number(e);if(!Number.isInteger(n)||n<=0)throw Error(`${t} must be a positive integer.`);return n}function Y(e){return[...new Set(e)]}function X(t){return e.includes(t)}async function Z(e){try{return await n(e,g.F_OK),!0}catch{return!1}}async function Q(e){try{return(await s(e)).isFile()}catch{return!1}}function $(e){return e.replace(/[.*+?^${}()|[\]\\]/gu,`\\$&`)}export{A as createTauriReleaseUpload,k as createTauriUpdateManifest,x as parseTauriReleasePlatform,b as parseTauriReleasePlatformList,D as prepareTauriRelease,S as resolveTauriReleasePlan,E as restoreTauriReleaseMetadata,O as uploadTauriReleaseToB2,w as validateTauriReleaseIdentifier,C as validateTauriReleasePlan,T as writeTauriReleaseMetadata};

package/dist/deploy/version.d.ts

@@ -1,24 +0,0 @@
-import { DeployEnvironment } from "./config.js";
-
-//#region deploy/version.d.ts
-type PackageJson = {
-  name?: string;
-  version?: string;
-  [key: string]: unknown;
-};
-type ReleasePackageJson = PackageJson & {
-  name: string;
-  version: string;
-};
-declare function nextReleaseVersion(currentVersion: string, now?: Date): string;
-declare function releaseName(packageName: string, version: string): string;
-declare function stagingReleaseVersion(currentVersion: string, revision: string): string;
-declare function resolveReleaseVersion(environment: DeployEnvironment, currentVersion: string, revision: string, now?: Date): string;
-declare function formatReleaseDate(date: Date): string;
-declare function readPackageJson(path?: string): Promise<{
-  packageJson: ReleasePackageJson;
-  source: string;
-}>;
-declare function writePackageVersion(path: string, packageJson: PackageJson, version: string): Promise<void>;
-//#endregion
-export { formatReleaseDate, nextReleaseVersion, readPackageJson, releaseName, resolveReleaseVersion, stagingReleaseVersion, writePackageVersion };

package/dist/deploy/version.js

@@ -1 +0,0 @@
-import{readFile as e,writeFile as t}from"node:fs/promises";function n(e,t=new Date){let n=l(e),r=o(t),i=n.minor===r?n.patch+1:0;return`${n.major}.${r}.${i}`}function r(e,t){return`${e}@${t}`}function i(e,t){return`${e}-staging.${t}`}function a(e,t,r,a=new Date){return e===`production`?n(t,a):i(t,r)}function o(e){return`${String(e.getFullYear())}${String(e.getMonth()+1).padStart(2,`0`)}${String(e.getDate()).padStart(2,`0`)}`}async function s(t=`package.json`){let n=await e(t,`utf8`),r=JSON.parse(n);if(!r.name)throw Error(`${t} is missing a package name.`);if(!r.version)throw Error(`${t} is missing a package version.`);return{packageJson:r,source:n}}async function c(e,n,r){await t(e,`${JSON.stringify({...n,version:r},null,2)}\n`)}function l(e){let t=/^(?<major>\d+)\.(?<minor>\d+)\.(?<patch>\d+)$/u.exec(e);if(!t?.groups)throw Error(`Invalid package version "${e}". Expected major.minor.patch.`);return{major:Number(t.groups.major),minor:t.groups.minor,patch:Number(t.groups.patch)}}export{o as formatReleaseDate,n as nextReleaseVersion,s as readPackageJson,r as releaseName,a as resolveReleaseVersion,i as stagingReleaseVersion,c as writePackageVersion};