some cleanup of publish functions

Author: jjallaire

src/command/publish/cmd.ts

@@ -38,7 +38,7 @@ import {
   handleUnauthorized,
   resolveAccount,
 } from "./account.ts";
-import { updateProjectPublishConfig } from "../../publish/config.ts";
+import { recordProjectPublishDeployment } from "../../publish/config.ts";
 import { render, renderServices } from "../render/render-shared.ts";
 import { projectOutputDir } from "../../project/project-shared.ts";
 import { PublishRecord } from "../../publish/types.ts";
@@ -130,9 +130,11 @@ async function publish(
       target,
     );
     if (publishRecord) {
-      await updateProjectPublishConfig(options.project, {
-        [provider.name]: [publishRecord],
-      });
+      recordProjectPublishDeployment(
+        options.project,
+        provider.name,
+        publishRecord,
+      );
     }
 
     // open browser if requested

src/command/publish/deployment.ts

@@ -12,7 +12,7 @@ import { Confirm } from "cliffy/prompt/confirm.ts";
 
 import { findProvider, PublishDeployment } from "../../publish/provider.ts";
 
-import { projectPublishConfig } from "../../publish/config.ts";
+import { projectPublishDeployments } from "../../publish/config.ts";
 
 import { resolveAccount } from "./account.ts";
 import { PublishOptions } from "./options.ts";
@@ -74,7 +74,7 @@ export async function publishDeployments(
   providerFilter?: string,
 ): Promise<PublishDeployment[]> {
   const deployments: PublishDeployment[] = [];
-  const config = projectPublishConfig(options.project);
+  const config = projectPublishDeployments(options.project);
   for (const providerName of Object.keys(config)) {
     if (providerFilter && (providerName !== providerFilter)) {
       continue;

src/project/project-shared.ts

@@ -51,14 +51,6 @@ export function projectVarsFile(dir: string): string | undefined {
     .find(existsSync);
 }
 
-export const kDefaultProjectPublishFile = "_publish.yml";
-
-export function projectPublishFile(dir: string): string | undefined {
-  return [kDefaultProjectPublishFile, "_publish.yaml"]
-    .map((file) => join(dir, file))
-    .find(existsSync);
-}
-
 export function projectOffset(context: ProjectContext, input: string) {
   const projDir = Deno.realPathSync(context.dir);
   const inputDir = Deno.realPathSync(dirname(input));

src/publish/common/publish.ts

@@ -27,6 +27,7 @@ export interface PublishDeploy {
   id?: string;
   state?: string;
   required?: string[];
+  url?: string;
   admin_url?: string;
 }
 
@@ -103,12 +104,7 @@ export async function publishSite<
     // wait for it to be ready
     while (true) {
       siteDeploy = await handler.getDeploy(siteDeploy.id!);
-      if (siteDeploy.state === "prepared") {
-        if (!siteDeploy.required) {
-          throw new Error(
-            "Site deploy prepared but no required files provided",
-          );
-        }
+      if (siteDeploy.state === "prepared" || siteDeploy.state === "ready") {
         break;
       }
       await sleep(250);
@@ -141,21 +137,23 @@ export async function publishSite<
   completeMessage(`Uploading files (complete)`);
 
   // wait on ready
+  let targetUrl = target.url;
   let adminUrl = target.url;
   await withSpinner({
     message: "Deploying published site",
   }, async () => {
     while (true) {
       const deployReady = await handler.getDeploy(siteDeploy?.id!);
       if (deployReady.state === "ready") {
+        targetUrl = deployReady.url || targetUrl;
         adminUrl = deployReady.admin_url || adminUrl;
         break;
       }
       await sleep(500);
     }
   });
 
-  completeMessage(`Published: ${target.url}\n`);
+  completeMessage(`Published: ${targetUrl}\n`);
 
-  return [target, new URL(adminUrl)];
+  return [{ ...target, url: targetUrl }, new URL(adminUrl)];
 }

src/publish/config.ts

@@ -7,46 +7,57 @@
 
 import { stringify } from "encoding/yaml.ts";
 import { join } from "path/mod.ts";
+import { existsSync } from "fs/mod.ts";
 
 import { Metadata } from "../config/types.ts";
-import { mergeConfigs } from "../core/config.ts";
 import { readYaml, readYamlFromString } from "../core/yaml.ts";
-import {
-  kDefaultProjectPublishFile,
-  projectPublishFile,
-} from "../project/project-shared.ts";
 import { ProjectContext } from "../project/types.ts";
-import { ProjectPublish } from "./types.ts";
+import { PublishDeployments, PublishRecord } from "./types.ts";
 
-export function projectPublishConfig(
+export function projectPublishDeployments(
   project: ProjectContext,
-): ProjectPublish {
-  const projectDir = project.dir;
-  const publishFile = projectPublishFile(projectDir);
-  if (publishFile) {
-    return readYaml(publishFile) as ProjectPublish;
+): PublishDeployments {
+  const deplomentsFile = publishDeploymentsFile(project.dir);
+  if (deplomentsFile) {
+    return readYaml(deplomentsFile) as PublishDeployments;
   } else {
-    return {} as ProjectPublish;
+    return {} as PublishDeployments;
   }
 }
 
-export function updateProjectPublishConfig(
-  target: ProjectContext,
-  updateConfig: ProjectPublish,
+export function recordProjectPublishDeployment(
+  project: ProjectContext,
+  provider: string,
+  publish: PublishRecord,
 ) {
+  // read base config
   let indent = 2;
-  let baseConfig: Metadata = {};
-  const projectDir = target.dir;
-  const publishFile = projectPublishFile(projectDir);
-  if (publishFile) {
-    const publishFileYaml = Deno.readTextFileSync(publishFile);
-    indent = detectIndentLevel(publishFileYaml);
-    baseConfig = readYamlFromString(publishFileYaml) as Metadata;
+  let deployments: PublishDeployments = {};
+  const projectDir = project.dir;
+  const deploymentsFile = publishDeploymentsFile(project.dir);
+  if (deploymentsFile) {
+    const deploymentsFileYaml = Deno.readTextFileSync(deploymentsFile);
+    indent = detectIndentLevel(deploymentsFileYaml);
+    deployments = readYamlFromString(deploymentsFileYaml) as PublishDeployments;
+  }
+
+  // update as required
+  if (deployments[provider]) {
+    const deploymentIdx = deployments[provider].findIndex(
+      (published) => published.id === publish.id,
+    );
+    if (deploymentIdx !== -1) {
+      deployments[provider][deploymentIdx] = publish;
+    } else {
+      deployments[provider].push(publish);
+    }
+  } else {
+    deployments[provider] = [publish];
   }
-  const updatedConfig = mergeConfigs(baseConfig, updateConfig);
+
   Deno.writeTextFileSync(
-    publishFile || join(projectDir, kDefaultProjectPublishFile),
-    stringifyPublishConfig(updatedConfig, indent),
+    deploymentsFile || join(projectDir, kDefaultPublishDeploymetsFile),
+    stringifyPublishConfig(deployments, indent),
   );
 }
 
@@ -65,3 +76,11 @@ function detectIndentLevel(yaml: string) {
   const spaceMatch = yaml.match(/\n(\s+)/);
   return spaceMatch ? spaceMatch[1].length : 2;
 }
+
+const kDefaultPublishDeploymetsFile = "_publish.yml";
+
+export function publishDeploymentsFile(dir: string): string | undefined {
+  return [kDefaultPublishDeploymetsFile, "_publish.yaml"]
+    .map((file) => join(dir, file))
+    .find(existsSync);
+}

src/publish/netlify/netlify.ts

@@ -157,25 +157,31 @@ function publish(
   const handler: PublishHandler<Site, Deploy> = {
     name: kNetlify,
     createSite: async () => {
-      return await client.site.createSite({
-        site: {
-          force_ssl: true,
-        },
-      }) as unknown as Site;
+      return withSslUrl(
+        await client.site.createSite({
+          site: {
+            force_ssl: true,
+          },
+        }) as unknown as Site,
+      );
     },
     createDeploy: async (siteId: string, files: Record<string, string>) => {
-      return await client.deploy.createSiteDeploy({
-        siteId,
-        deploy: {
-          files,
-          async: true,
-        },
-      });
+      return withSslUrl(
+        await client.deploy.createSiteDeploy({
+          siteId,
+          deploy: {
+            files,
+            async: true,
+          },
+        }),
+      );
     },
     getDeploy: async (deployId: string) => {
-      return await client.deploy.getDeploy({
-        deployId,
-      });
+      return withSslUrl(
+        await client.deploy.getDeploy({
+          deployId,
+        }),
+      );
     },
     uploadDeployFile: async (
       deployId: string,
@@ -195,6 +201,13 @@ function publish(
   return publishSite<Site, Deploy>(handler, render, target);
 }
 
+function withSslUrl(obj: { ssl_url?: string; url?: string }) {
+  return {
+    ...obj,
+    url: obj.ssl_url || obj.url,
+  };
+}
+
 function isUnauthorized(err: Error) {
   return err instanceof ApiError && err.status === 401;
 }

src/publish/types.ts

@@ -5,7 +5,7 @@
 *
 */
 
-export type ProjectPublish = Record<string, Array<PublishRecord>>;
+export type PublishDeployments = Record<string, Array<PublishRecord>>;
 
 export type PublishRecord = {
   id: string;