@wtfalch/foundry 0.12.0 → 0.13.0

package/dist/plan/adopt.js

@@ -1,252 +0,0 @@
-import { appStepKey } from './platform-diff.js';
-/** The `foundry_adoptions.resource_key` of the org's adopted tunnel: also its `serviceIds` key (#312). */
-export const adoptedTunnelKey = (org) => `cloudflare:tunnel:${org.id}`;
-/** The `foundry_adoptions.resource_key` of the org's adopted connector app (#312). */
-export const adoptedConnectorKey = (org) => `cloudflare:connector:${org.id}`;
-/** Every resource the org adopts, the database first, then the apps, the tunnel and its connector. */
-export function adoptedResources(org) {
-    if (!org.hosting.enabled)
-        return [];
-    const database = org.hosting.adopt?.database;
-    const resources = [];
-    if (database) {
-        resources.push({ resourceKey: `coolify:database:${org.id}`, kind: 'database', uuid: database });
-    }
-    for (const entry of org.hosting.entries) {
-        if (!entry.adopt)
-            continue;
-        resources.push({
-            resourceKey: `coolify:app:${appStepKey(org, entry.key)}`,
-            kind: 'app',
-            uuid: entry.adopt.app,
-            entry,
-        });
-    }
-    const { tunnel, connectorApp } = org.hosting.adopt ?? {};
-    if (tunnel)
-        resources.push({ resourceKey: adoptedTunnelKey(org), kind: 'tunnel', uuid: tunnel });
-    if (connectorApp) {
-        resources.push({
-            resourceKey: adoptedConnectorKey(org),
-            kind: 'connector',
-            uuid: connectorApp,
-        });
-    }
-    return resources;
-}
-/**
- * Every uuid the org declares as adopted, whether or not hosting is enabled
- * now: a uuid in this set is never stopped or deleted by foundry (#311).
- */
-export function declaredAdoptUuids(org) {
-    const uuids = new Set();
-    if (org.hosting.adopt?.database)
-        uuids.add(org.hosting.adopt.database);
-    if (org.hosting.adopt?.tunnel)
-        uuids.add(org.hosting.adopt.tunnel);
-    if (org.hosting.adopt?.connectorApp)
-        uuids.add(org.hosting.adopt.connectorApp);
-    for (const entry of org.hosting.entries)
-        if (entry.adopt)
-            uuids.add(entry.adopt.app);
-    return uuids;
-}
-/**
- * A snapshot is ACTIVE when its row is `adopted` or `confirmed` and the uuid
- * it recorded is the uuid the org declares now (#311). Only then may foundry
- * write to the live resource.
- */
-export function isActiveSnapshot(row, uuid) {
-    return (row !== null &&
-        row !== undefined &&
-        (row.state === 'adopted' || row.state === 'confirmed') &&
-        row.settings.uuid === uuid);
-}
-/**
- * A row in `adopted`, `confirmed` or `restored` protects its key: foundry never
- * manages, stops or deletes that resource as its own. Only `released` lets go (#311).
- */
-export function protectsKey(row) {
-    return row?.state === 'adopted' || row?.state === 'confirmed' || row?.state === 'restored';
-}
-/** Where the secret part of a snapshot lives in the `AdoptionVault`. */
-export function adoptionVaultRef(org, resource) {
-    return `foundry:adopt:${org.id}:${resource.kind === 'app' ? `app:${resource.entry.key}` : resource.kind}`;
-}
-/** Coolify's field names for the non-secret settings an app snapshot keeps. */
-const APP_SETTING_FIELDS = [
-    'fqdn',
-    'git_branch',
-    'base_directory',
-    'publish_directory',
-    'build_pack',
-    'ports_exposes',
-    'health_check_enabled',
-    'health_check_path',
-    'health_check_port',
-    'health_check_method',
-    'health_check_return_code',
-    'health_check_scheme',
-    'health_check_interval',
-    'health_check_timeout',
-    'health_check_retries',
-    'health_check_start_period',
-    'custom_network_aliases',
-    'is_auto_deploy_enabled',
-    'limits_memory',
-    'limits_memory_swap',
-    'limits_memory_swappiness',
-    'limits_memory_reservation',
-    'limits_cpus',
-    'limits_cpuset',
-    'limits_cpu_shares',
-];
-export function snapshotAppSettings(live) {
-    return Object.fromEntries(APP_SETTING_FIELDS.map((field) => [field, live[field] ?? null]));
-}
-export const bareName = (name) => name.trim().replace(/^https?:\/\//, '');
-export const liveNames = (live) => typeof live.fqdn === 'string' ? live.fqdn.split(',').filter(Boolean).map(bareName) : [];
-/**
- * What an adopted entry changes on its live app: only a setting it declares
- * that differs from live. The entry cannot tell a declared `branch`,
- * `buildPack` or `autoDeploy` from its default, so those stay as they are; a
- * `null` folder or port and an empty name list declare nothing. Never
- * `custom_network_aliases`.
- */
-export function adoptedAppPatch(entry, names, live) {
-    const patch = {};
-    const folderField = entry.buildPack === 'static' ? 'publish_directory' : 'base_directory';
-    if (entry.folder !== null && (live[folderField] ?? '/') !== `/${entry.folder}`) {
-        patch[folderField] = `/${entry.folder}`;
-    }
-    if (entry.port !== null &&
-        entry.buildPack !== 'static' &&
-        `${live.ports_exposes}` !== `${entry.port}`) {
-        patch.ports_exposes = String(entry.port);
-    }
-    if (names.length > 0 && [...names].sort().join() !== liveNames(live).sort().join()) {
-        patch.domains = names.join(',');
-    }
-    return patch;
-}
-/** One line per setting the patch changes, old value beside new. */
-export function adoptedPatchDetails(patch, live) {
-    return Object.entries(patch).map(([field, value]) => {
-        const old = field === 'domains' ? live.fqdn : live[field];
-        return `${field}: ${old ?? 'unset'} -> ${value}`;
-    });
-}
-/**
- * The PATCH body that puts an app's snapshot settings back. A field is sent
- * only when the entry's declaration would have changed it from the snapshot
- * (`adoptedAppPatch`), so a setting foundry never touched, or a person edited
- * later, stays. With no entry, a field is sent when `live` differs from the
- * snapshot. Coolify reads `fqdn` but takes `domains`. A field the snapshot had
- * as null is cleared the way the plain app path clears it: a folder back to
- * `/`, domains to the empty list. A port is never cleared, as on that path.
- */
-export function restoreAppPatch(entry, names, settings, live) {
-    const isStatic = (entry?.buildPack ?? settings.build_pack) === 'static';
-    const folderField = isStatic ? 'publish_directory' : 'base_directory';
-    const changed = new Set(Object.keys(entry ? adoptedAppPatch(entry, names, settings) : {}));
-    if (!entry) {
-        if ((live[folderField] ?? '/') !== (settings[folderField] ?? '/'))
-            changed.add(folderField);
-        if (`${live.ports_exposes}` !== `${settings.ports_exposes}`)
-            changed.add('ports_exposes');
-        if (liveNames(settings).sort().join() !== liveNames(live).sort().join())
-            changed.add('domains');
-    }
-    const patch = {};
-    if (changed.has(folderField))
-        patch[folderField] = settings[folderField] ?? '/';
-    if (changed.has('domains'))
-        patch.domains = settings.fqdn ?? '';
-    if (!isStatic && settings.ports_exposes != null && changed.has('ports_exposes')) {
-        patch.ports_exposes = settings.ports_exposes;
-    }
-    return patch;
-}
-const isWildcard = (route) => route.hostname?.startsWith('*') ?? false;
-const isCatchAll = (route) => route !== undefined && route.hostname === undefined && route.path === undefined;
-/** A hostname as compared: lower case, no trailing dot (DNS names ignore both). */
-export const normalizeHostname = (hostname) => hostname.toLowerCase().replace(/\.$/, '');
-const sameName = (a, b) => a !== undefined && normalizeHostname(a) === normalizeHostname(b);
-const hasName = (names, hostname) => hostname !== undefined && [...names].some((name) => sameName(hostname, name));
-/** The route foundry writes for a name: nothing but the hostname and the service. */
-const isFoundryRoute = (route, service) => route.service === service && Object.keys(route).length === 2;
-/** Puts `back` before the first wildcard or hostname-less route of `rest`, so a person's order stays. */
-function putBack(rest, back) {
-    const at = rest.findIndex((route) => route.hostname === undefined || isWildcard(route));
-    return at < 0 ? [...rest, ...back] : [...rest.slice(0, at), ...back, ...rest.slice(at)];
-}
-/** A live route foundry wrote for a name it dropped: written, no longer declared, exactly foundry's own. */
-const isDroppedRoute = (route, declared, service, written) => hasName(written, route.hostname) &&
-    !hasName(declared, route.hostname) &&
-    isFoundryRoute(route, service);
-/**
- * What the merge leaves alone: every live route that is not for a declared
- * name and not foundry's own route for a name it dropped. Whatever its shape:
- * a hostname, only a `path`, or neither.
- */
-export function foreignRoutes(live, declared, service, written) {
-    return live.filter((route) => !hasName(declared, route.hostname) && !isDroppedRoute(route, declared, service, written));
-}
-/** The declared names whose live routes the merge replaces: there are some, and they are not already foundry's one route. */
-export function replacedNames(live, declared, service) {
-    return declared.filter((hostname) => {
-        const same = live.filter((route) => sameName(route.hostname, hostname));
-        const [only] = same;
-        return only !== undefined && !(same.length === 1 && isFoundryRoute(only, service));
-    });
-}
-/** The names foundry removes from `live`: written, no longer declared, still its own route. */
-export const removedNames = (live, declared, service, written) => [
-    ...new Set(live
-        .filter((route) => isDroppedRoute(route, declared, service, written))
-        .map((route) => route.hostname)),
-];
-/**
- * The ingress list an adopted tunnel gets (#312): the declared exact names,
- * then every foreign live route in its live order and unchanged, with the
- * snapshot's routes for a name foundry dropped put back among them, then the
- * declared wildcards, then the live catch-all as it is. Only a live list that
- * does not end in a catch-all gets `http_status:404`.
- */
-export function mergeIngress(live, declared, service, written, snapshot) {
-    const dropped = removedNames(live, declared, service, written);
-    const tail = live.at(-1);
-    const foreign = foreignRoutes(live, declared, service, written);
-    const catchAll = isCatchAll(tail) ? tail : { service: 'http_status:404' };
-    const middle = isCatchAll(tail) ? foreign.slice(0, -1) : foreign;
-    const back = snapshot.filter((route) => hasName(dropped, route.hostname));
-    const route = (hostname) => ({ hostname, service });
-    return [
-        ...declared.filter((hostname) => !hostname.startsWith('*')).map(route),
-        ...putBack(middle, back),
-        ...declared.filter((hostname) => hostname.startsWith('*')).map(route),
-        catchAll,
-    ];
-}
-/**
- * The ingress list restore writes (#312): the live list without foundry's own
- * route for a name it wrote (`written` accumulates for the life of the
- * snapshot), plus the snapshot's routes for that name. A name with no live
- * route that is exactly foundry's is left alone, as is a route a person added
- * or edited, and the live catch-all. The `http_status:404` foundry appended is
- * removed only while it is still last and the snapshot had no catch-all; an
- * empty snapshot keeps the live catch-all, or gets one.
- */
-export function restoreIngress(live, snapshot, service, written) {
-    const isOurs = (route) => hasName(written, route.hostname) && isFoundryRoute(route, service);
-    const swapped = (route) => hasName(live.filter(isOurs).map((r) => r.hostname), route.hostname);
-    const appended = snapshot.length > 0 &&
-        !isCatchAll(snapshot.at(-1)) &&
-        isCatchAll(live.at(-1)) &&
-        live.at(-1)?.service === 'http_status:404';
-    const rest = live.filter((route, index) => !isOurs(route) && !(appended && index === live.length - 1));
-    const restored = putBack(rest, snapshot.filter(swapped));
-    return snapshot.length === 0 && !isCatchAll(restored.at(-1))
-        ? [...restored, { service: 'http_status:404' }]
-        : restored;
-}

package/dist/plan/adoption-vault.d.ts

@@ -1,9 +0,0 @@
-/**
- * Where an adoption keeps the secret part of its snapshot (#311): the live
- * app's env values. The row in `foundry_adoptions` holds only the ref. Same
- * shape as the `heldKeys` port (`../bootstrap/bootstrap.ts`).
- */
-export interface AdoptionVault {
-    put(ref: string, value: string): Promise<void>;
-    resolve(ref: string): Promise<string | null>;
-}

package/dist/plan/adoption-vault.js

@@ -1 +0,0 @@
-export {};