@synopackageland/cli 0.3.10 → 0.4.0

package/dist/deploy/spk-version.js

@@ -1,117 +1,31 @@
 import { loadContract } from "../contract/load.js";
-import { comparePackageVersions, CURATED_BUILD_OFFSET, PERSONAL_BUILD_MAX, } from "@synopackageland/package-source/index-manifest";
-import { fetchPackageSourceManifest, fetchPackageSourceManifestFromR2, resolvePublishTarget, } from "@synopackageland/package-source/publish-spk";
-import { publishBuiltSpk } from "./catalog-publish.js";
-import { isDevelopmentPackageIdentity } from "./identity-shared.js";
-const LIVE_TEST_FALLBACK_ORIGIN = "https://syno-package-source-throwaway.bidacumen.workers.dev";
-export class DeployPersonalBuildExhaustedError extends Error {
-    code = "DEPLOY_PERSONAL_BUILD_EXHAUSTED";
-    constructor() {
-        super(`Personal Package Build range exhausted at ${PERSONAL_BUILD_MAX}`);
-        this.name = "DeployPersonalBuildExhaustedError";
-    }
-}
-export class DeployVersionNotAscendingError extends Error {
-    code = "DEPLOY_VERSION_NOT_ASCENDING";
-    constructor(contractVersion, proposedVersion, existingVersion) {
-        super(`Contract version ${contractVersion} would produce ${proposedVersion}, which is not higher than installed package version ${existingVersion}.`);
-        this.name = "DeployVersionNotAscendingError";
-    }
-}
-function baseVersion(version) {
-    const match = /^(.+)-(\d+)$/.exec(version);
-    return match ? match[1] : version;
-}
-function buildNumber(version) {
-    const match = /^.+-(\d+)$/.exec(version);
-    if (!match) {
-        return undefined;
-    }
-    const build = Number(match[1]);
-    return Number.isSafeInteger(build) ? build : undefined;
-}
-function personalBuildNumber(version) {
-    const build = buildNumber(version);
-    return build !== undefined && build >= 1 && build <= PERSONAL_BUILD_MAX ? build : undefined;
-}
-export function resolvePersonalDeploySpkVersion(contractVersion, candidates = {}) {
-    const base = baseVersion(contractVersion);
-    const existingVersions = [candidates.installed, candidates.feed].filter((version) => typeof version === "string" && version.length > 0);
-    const latestExisting = existingVersions.sort(comparePackageVersions).at(-1);
-    let proposedVersion;
-    if (!latestExisting || baseVersion(latestExisting) !== base) {
-        proposedVersion = `${base}-0001`;
-    }
-    else {
-        const latestBuild = buildNumber(latestExisting);
-        if (latestBuild === undefined || latestBuild >= CURATED_BUILD_OFFSET) {
-            throw new DeployPersonalBuildExhaustedError();
+/** Increment the installed build only for the same application version. */
+export function nextDeployVersion(version, installed) {
+    const match = /^(\d+(?:\.\d+)*)(?:-(\d+))?$/.exec(version);
+    if (!match)
+        throw new Error(`Invalid package version: ${version}`);
+    const base = match[1];
+    let build = Number(match[2] ?? 1);
+    if (installed) {
+        const previous = /^(\d+(?:\.\d+)*)(?:-(\d+))?$/.exec(installed);
+        if (!previous)
+            throw new Error(`Cannot compare installed version: ${installed}`);
+        const a = base.split('.').map(Number), b = previous[1].split('.').map(Number);
+        let order = 0;
+        for (let i = 0; i < Math.max(a.length, b.length); i++) {
+            order = (a[i] ?? 0) - (b[i] ?? 0);
+            if (order !== 0)
+                break;
         }
-        const nextBuild = latestBuild + 1;
-        if (nextBuild > PERSONAL_BUILD_MAX) {
-            throw new DeployPersonalBuildExhaustedError();
-        }
-        proposedVersion = `${base}-${String(nextBuild).padStart(4, "0")}`;
-    }
-    if (candidates.installed &&
-        comparePackageVersions(proposedVersion, candidates.installed) <= 0) {
-        throw new DeployVersionNotAscendingError(contractVersion, proposedVersion, candidates.installed);
+        if (order < 0)
+            throw new Error(`Refusing downgrade from ${installed} to ${version}`);
+        if (order === 0)
+            build = Math.max(build, Number(previous[2] ?? 0) + 1);
     }
-    return proposedVersion;
-}
-function latestPersonalFeedVersion(packageId, manifest) {
-    return (manifest?.packages ?? [])
-        .filter((entry) => entry.package === packageId)
-        .map((entry) => entry.version)
-        .filter((version) => personalBuildNumber(version) !== undefined)
-        .sort(comparePackageVersions)
-        .at(-1);
-}
-async function resolvePackageSourceManifest(origin) {
-    try {
-        const manifest = await fetchPackageSourceManifest(origin);
-        if (manifest) {
-            return manifest;
-        }
-        if (origin !== LIVE_TEST_FALLBACK_ORIGIN) {
-            return fetchPackageSourceManifest(LIVE_TEST_FALLBACK_ORIGIN);
-        }
-    }
-    catch {
-        return null;
-    }
-    return null;
-}
-async function resolveOfflineDeploySpkVersion(project, host, packageId) {
-    const contract = loadContract(project.contractPath).contract;
-    const contractVersion = String(contract.version ?? "1.0.0");
-    const installed = (await host.isPackageInstalled(packageId))
-        ? await host.getInstalledPackageVersion?.(packageId)
-        : undefined;
-    return resolvePersonalDeploySpkVersion(contractVersion, { installed });
+    if (!Number.isSafeInteger(build) || build < 1)
+        throw new Error('Invalid build number');
+    return `${base}-${String(build).padStart(4, '0')}`;
 }
 export async function resolveDeploySpkVersion(project, host, packageId) {
-    try {
-        if (host.installationId !== "live-nas" || isDevelopmentPackageIdentity(packageId)) {
-            return resolveOfflineDeploySpkVersion(project, host, packageId);
-        }
-        const contract = loadContract(project.contractPath).contract;
-        const target = resolvePublishTarget();
-        const manifest = (await fetchPackageSourceManifestFromR2(target)) ??
-            (await resolvePackageSourceManifest(target.origin));
-        const contractVersion = String(contract.version ?? "1.0.0");
-        const installed = await host.getInstalledPackageVersion?.(packageId);
-        const feed = latestPersonalFeedVersion(packageId, manifest);
-        return resolvePersonalDeploySpkVersion(contractVersion, { installed, feed });
-    }
-    catch (error) {
-        if (error.code === "PERSONAL_BUILD_EXHAUSTED") {
-            throw new DeployPersonalBuildExhaustedError();
-        }
-        throw error;
-    }
-}
-export async function publishDeploySpk(spkPath) {
-    const published = await publishBuiltSpk(spkPath);
-    return published.version;
+    return nextDeployVersion(String(loadContract(project.contractPath).contract.version), await host.getInstalledPackageVersion?.(packageId));
 }

package/dist/dev.d.ts

@@ -2,12 +2,10 @@ import type { ProjectRoot } from "./discovery.js";
 import type { ComposeRunner } from "./compose/runner.js";
 export interface DevOptions {
     project: ProjectRoot;
-    filesRoot?: string;
     composeRunner?: ComposeRunner;
 }
 export interface DevHandle {
-    brokerBaseUrl: string;
-    bootstrapPath: string;
     close(): Promise<void>;
 }
+/** Run the application's own Compose project locally. */
 export declare function runDev(options: DevOptions): Promise<DevHandle>;

package/dist/dev.js

@@ -1,31 +1,17 @@
-import { loadContract } from "./contract/load.js";
-import { writeMockBrokerBootstrap } from "./mock-broker/bootstrap.js";
-import { startMockBroker } from "./mock-broker/server.js";
+import { existsSync } from "node:fs";
 import { createDockerComposeRunner } from "./compose/runner.js";
+/** Run the application's own Compose project locally. */
 export async function runDev(options) {
-    const parsed = loadContract(options.project.contractPath);
-    const packageId = String(parsed.contract.package);
-    const broker = await startMockBroker({
-        packageId,
-        filesRoot: options.filesRoot,
-    });
-    const bootstrapPath = writeMockBrokerBootstrap(options.project.root, {
-        brokerBaseUrl: broker.baseUrl,
-        jwksUrl: broker.jwksUrl,
-        packageId,
-        mock: true,
-    });
-    const composeRunner = options.composeRunner ?? createDockerComposeRunner();
-    await composeRunner.up(options.project.root);
-    await composeRunner.waitReady(options.project.root);
-    return {
-        brokerBaseUrl: broker.baseUrl,
-        bootstrapPath,
-        close: async () => {
-            if (composeRunner.down) {
-                await composeRunner.down(options.project.root);
-            }
-            await broker.close();
-        },
-    };
+    if (!existsSync(options.project.composePath))
+        throw new Error('dev requires compose.yaml');
+    const runner = options.composeRunner ?? createDockerComposeRunner();
+    try {
+        await runner.up(options.project.root);
+        await runner.waitReady(options.project.root);
+    }
+    catch (error) {
+        await runner.down?.(options.project.root);
+        throw error;
+    }
+    return { close: async () => { await runner.down?.(options.project.root); } };
 }