@webstudio-is/trpc-interface 0.68.0 → 0.69.0

package/lib/authorize/project.server.js

@@ -21,7 +21,7 @@ const hasProjectPermit = async (props, context) => {
     const { authorizeTrpc } = authorization;
     const checks = [];
     const namespace = "Project";
-    if (props.permit === "view" && context.authorization.buildEnv === "prod") {
+    if (props.permit === "view" && context.authorization.isServiceCall) {
       return true;
     }
     if (props.permit === "view" && props.projectId === "62154aaef0cb0860ccf85d6e") {

package/lib/cjs/authorize/project.server.js

@@ -46,7 +46,7 @@ const hasProjectPermit = async (props, context) => {
     const { authorizeTrpc } = authorization;
     const checks = [];
     const namespace = "Project";
-    if (props.permit === "view" && context.authorization.buildEnv === "prod") {
+    if (props.permit === "view" && context.authorization.isServiceCall) {
       return true;
     }
     if (props.permit === "view" && props.projectId === "62154aaef0cb0860ccf85d6e") {

package/lib/cjs/shared/deployment.js

@@ -0,0 +1,48 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var deployment_exports = {};
+__export(deployment_exports, {
+  deploymentRouter: () => deploymentRouter
+});
+module.exports = __toCommonJS(deployment_exports);
+var import_zod = require("zod");
+var import_trpc = require("./trpc");
+const PublishInput = import_zod.z.object({
+  // used to load build data from the builder see routes/rest.build.$buildId.ts
+  buildId: import_zod.z.string(),
+  builderApiOrigin: import_zod.z.string(),
+  // preview support
+  branchName: import_zod.z.string(),
+  // action log helper (not used for deployment, but for action logs readablity)
+  projectDomainName: import_zod.z.string()
+});
+const Output = import_zod.z.discriminatedUnion("success", [
+  import_zod.z.object({
+    success: import_zod.z.literal(true)
+  }),
+  import_zod.z.object({
+    success: import_zod.z.literal(false),
+    error: import_zod.z.string()
+  })
+]);
+const deploymentRouter = (0, import_trpc.router)({
+  publish: import_trpc.procedure.input(PublishInput).output(Output).mutation(async ({ input, ctx }) => {
+    return { success: false, error: "Not implemented" };
+  })
+});

package/lib/cjs/shared/domain.js

@@ -0,0 +1,98 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var domain_exports = {};
+__export(domain_exports, {
+  domainRouter: () => domainRouter
+});
+module.exports = __toCommonJS(domain_exports);
+var import_zod = require("zod");
+var import_trpc = require("./trpc");
+const CreateInput = import_zod.z.object({ domain: import_zod.z.string(), txtRecord: import_zod.z.string() });
+const Input = import_zod.z.object({ domain: import_zod.z.string() });
+const createOutput = (data) => import_zod.z.discriminatedUnion("success", [
+  import_zod.z.object({ success: import_zod.z.literal(true), data }),
+  import_zod.z.object({ success: import_zod.z.literal(false), error: import_zod.z.string() })
+]);
+globalThis.dnsTxtEntries = globalThis.dnsTxtEntries ?? /* @__PURE__ */ new Map();
+globalThis.domainStates = globalThis.domainStates ?? /* @__PURE__ */ new Map();
+const domainRouter = (0, import_trpc.router)({
+  /**
+   * Verify TXT record and add custom domain entry to DNS
+   */
+  create: import_trpc.procedure.input(CreateInput).output(createOutput(import_zod.z.optional(import_zod.z.undefined()))).mutation(async ({ input, ctx }) => {
+    const record = dnsTxtEntries.get(input.domain);
+    if (record !== input.txtRecord) {
+      dnsTxtEntries.set(input.domain, input.txtRecord);
+      return {
+        success: false,
+        error: `TXT record does not match, expected "${input.txtRecord}" but got "${record ?? "undefined"}"`
+      };
+    }
+    domainStates.set(input.domain, "pending");
+    return { success: true };
+  }),
+  refresh: import_trpc.procedure.input(Input).output(createOutput(import_zod.z.optional(import_zod.z.undefined()))).mutation(async ({ input, ctx }) => {
+    return { success: true };
+  }),
+  /**
+   * Get status of verified domain
+   */
+  getStatus: import_trpc.procedure.input(Input).output(
+    createOutput(
+      import_zod.z.discriminatedUnion("status", [
+        import_zod.z.object({ status: import_zod.z.enum(["active", "pending"]) }),
+        import_zod.z.object({ status: import_zod.z.enum(["error"]), error: import_zod.z.string() })
+      ])
+    )
+  ).query(async ({ input, ctx }) => {
+    const domainState = domainStates.get(input.domain);
+    if (domainState === void 0) {
+      domainStates.set(input.domain, "pending");
+      return {
+        success: false,
+        error: `Domain ${input.domain} is not active`
+      };
+    }
+    if (domainState === "active") {
+      setTimeout(() => {
+        domainStates.set(input.domain, "error");
+      });
+    }
+    if (domainState === "pending" || domainState === "error") {
+      setTimeout(() => {
+        domainStates.set(input.domain, "active");
+      }, 5e3);
+    }
+    if (domainState === "error") {
+      return {
+        success: true,
+        data: {
+          status: "error",
+          error: "Domain cname verification failed"
+        }
+      };
+    }
+    return {
+      success: true,
+      data: {
+        status: domainState
+      }
+    };
+  })
+});

package/lib/cjs/shared/shared-router.js

@@ -23,6 +23,10 @@ __export(shared_router_exports, {
 module.exports = __toCommonJS(shared_router_exports);
 var import_trpc = require("./trpc");
 var import_authorization_router = require("./authorization-router");
+var import_domain = require("./domain");
+var import_deployment = require("./deployment");
 const sharedRouter = (0, import_trpc.router)({
-  authorize: import_authorization_router.authorizationRouter
+  authorize: import_authorization_router.authorizationRouter,
+  domain: import_domain.domainRouter,
+  deployment: import_deployment.deploymentRouter
 });

package/lib/shared/deployment.js

@@ -0,0 +1,28 @@
+import { z } from "zod";
+import { router, procedure } from "./trpc";
+const PublishInput = z.object({
+  // used to load build data from the builder see routes/rest.build.$buildId.ts
+  buildId: z.string(),
+  builderApiOrigin: z.string(),
+  // preview support
+  branchName: z.string(),
+  // action log helper (not used for deployment, but for action logs readablity)
+  projectDomainName: z.string()
+});
+const Output = z.discriminatedUnion("success", [
+  z.object({
+    success: z.literal(true)
+  }),
+  z.object({
+    success: z.literal(false),
+    error: z.string()
+  })
+]);
+const deploymentRouter = router({
+  publish: procedure.input(PublishInput).output(Output).mutation(async ({ input, ctx }) => {
+    return { success: false, error: "Not implemented" };
+  })
+});
+export {
+  deploymentRouter
+};

package/lib/shared/domain.js

@@ -0,0 +1,78 @@
+import { z } from "zod";
+import { router, procedure } from "./trpc";
+const CreateInput = z.object({ domain: z.string(), txtRecord: z.string() });
+const Input = z.object({ domain: z.string() });
+const createOutput = (data) => z.discriminatedUnion("success", [
+  z.object({ success: z.literal(true), data }),
+  z.object({ success: z.literal(false), error: z.string() })
+]);
+globalThis.dnsTxtEntries = globalThis.dnsTxtEntries ?? /* @__PURE__ */ new Map();
+globalThis.domainStates = globalThis.domainStates ?? /* @__PURE__ */ new Map();
+const domainRouter = router({
+  /**
+   * Verify TXT record and add custom domain entry to DNS
+   */
+  create: procedure.input(CreateInput).output(createOutput(z.optional(z.undefined()))).mutation(async ({ input, ctx }) => {
+    const record = dnsTxtEntries.get(input.domain);
+    if (record !== input.txtRecord) {
+      dnsTxtEntries.set(input.domain, input.txtRecord);
+      return {
+        success: false,
+        error: `TXT record does not match, expected "${input.txtRecord}" but got "${record ?? "undefined"}"`
+      };
+    }
+    domainStates.set(input.domain, "pending");
+    return { success: true };
+  }),
+  refresh: procedure.input(Input).output(createOutput(z.optional(z.undefined()))).mutation(async ({ input, ctx }) => {
+    return { success: true };
+  }),
+  /**
+   * Get status of verified domain
+   */
+  getStatus: procedure.input(Input).output(
+    createOutput(
+      z.discriminatedUnion("status", [
+        z.object({ status: z.enum(["active", "pending"]) }),
+        z.object({ status: z.enum(["error"]), error: z.string() })
+      ])
+    )
+  ).query(async ({ input, ctx }) => {
+    const domainState = domainStates.get(input.domain);
+    if (domainState === void 0) {
+      domainStates.set(input.domain, "pending");
+      return {
+        success: false,
+        error: `Domain ${input.domain} is not active`
+      };
+    }
+    if (domainState === "active") {
+      setTimeout(() => {
+        domainStates.set(input.domain, "error");
+      });
+    }
+    if (domainState === "pending" || domainState === "error") {
+      setTimeout(() => {
+        domainStates.set(input.domain, "active");
+      }, 5e3);
+    }
+    if (domainState === "error") {
+      return {
+        success: true,
+        data: {
+          status: "error",
+          error: "Domain cname verification failed"
+        }
+      };
+    }
+    return {
+      success: true,
+      data: {
+        status: domainState
+      }
+    };
+  })
+});
+export {
+  domainRouter
+};

package/lib/shared/shared-router.js

@@ -1,7 +1,11 @@
 import { router } from "./trpc";
 import { authorizationRouter } from "./authorization-router";
+import { domainRouter } from "./domain";
+import { deploymentRouter } from "./deployment";
 const sharedRouter = router({
-  authorize: authorizationRouter
+  authorize: authorizationRouter,
+  domain: domainRouter,
+  deployment: deploymentRouter
 });
 export {
   sharedRouter

package/lib/types/context/context.server.d.ts

@@ -12,11 +12,21 @@ type AuthorizationContext = {
      */
     authToken: string | undefined;
     /**
-     * buildEnv==="prod" only if we are loading project with production build
+     * Allow service 2 service communications to skip authorization for view calls
      */
-    buildEnv: "dev" | "prod";
+    isServiceCall: boolean;
     authorizeTrpc: TrpcInterfaceClient["authorize"];
 };
+type DomainContext = {
+    domainTrpc: TrpcInterfaceClient["domain"];
+};
+type DeploymentContext = {
+    deploymentTrpc: TrpcInterfaceClient["deployment"];
+    env: {
+        BUILDER_ORIGIN: string;
+        BRANCH_NAME: string;
+    };
+};
 /**
  * AppContext is a global context that is passed to all trpc/api queries/mutations
  * "authorization" is made inside the namespace because eventually there will be
@@ -24,5 +34,7 @@ type AuthorizationContext = {
  */
 export type AppContext = {
     authorization: AuthorizationContext;
+    domain: DomainContext;
+    deployment: DeploymentContext;
 };
 export {};

package/lib/types/shared/deployment.d.ts

@@ -0,0 +1,45 @@
+/**
+ * This is the ContentManagementService. It is currently used to publish content to a custom domain.
+ * In the future, additional methods, such as a 'preview' function, could be added.
+ **/
+export declare const deploymentRouter: import("@trpc/server").CreateRouterInner<import("@trpc/server").RootConfig<{
+    ctx: {};
+    meta: object;
+    errorShape: import("@trpc/server").DefaultErrorShape;
+    transformer: import("@trpc/server").DefaultDataTransformer;
+}>, {
+    publish: import("@trpc/server").BuildProcedure<"mutation", {
+        _config: import("@trpc/server").RootConfig<{
+            ctx: {};
+            meta: object;
+            errorShape: import("@trpc/server").DefaultErrorShape;
+            transformer: import("@trpc/server").DefaultDataTransformer;
+        }>;
+        _meta: object;
+        _ctx_out: {};
+        _input_in: {
+            buildId: string;
+            builderApiOrigin: string;
+            branchName: string;
+            projectDomainName: string;
+        };
+        _input_out: {
+            buildId: string;
+            builderApiOrigin: string;
+            branchName: string;
+            projectDomainName: string;
+        };
+        _output_in: {
+            success: true;
+        } | {
+            error: string;
+            success: false;
+        };
+        _output_out: {
+            success: true;
+        } | {
+            error: string;
+            success: false;
+        };
+    }, unknown>;
+}>;

package/lib/types/shared/domain.d.ts

@@ -0,0 +1,119 @@
+declare global {
+    var dnsTxtEntries: Map<string, string>;
+    var domainStates: Map<string, "active" | "pending" | "error">;
+}
+export declare const domainRouter: import("@trpc/server").CreateRouterInner<import("@trpc/server").RootConfig<{
+    ctx: {};
+    meta: object;
+    errorShape: import("@trpc/server").DefaultErrorShape;
+    transformer: import("@trpc/server").DefaultDataTransformer;
+}>, {
+    /**
+     * Verify TXT record and add custom domain entry to DNS
+     */
+    create: import("@trpc/server").BuildProcedure<"mutation", {
+        _config: import("@trpc/server").RootConfig<{
+            ctx: {};
+            meta: object;
+            errorShape: import("@trpc/server").DefaultErrorShape;
+            transformer: import("@trpc/server").DefaultDataTransformer;
+        }>;
+        _meta: object;
+        _ctx_out: {};
+        _input_in: {
+            domain: string;
+            txtRecord: string;
+        };
+        _input_out: {
+            domain: string;
+            txtRecord: string;
+        };
+        _output_in: {
+            success: true;
+            data?: undefined;
+        } | {
+            error: string;
+            success: false;
+        };
+        _output_out: {
+            success: true;
+            data?: undefined;
+        } | {
+            error: string;
+            success: false;
+        };
+    }, unknown>;
+    refresh: import("@trpc/server").BuildProcedure<"mutation", {
+        _config: import("@trpc/server").RootConfig<{
+            ctx: {};
+            meta: object;
+            errorShape: import("@trpc/server").DefaultErrorShape;
+            transformer: import("@trpc/server").DefaultDataTransformer;
+        }>;
+        _meta: object;
+        _ctx_out: {};
+        _input_in: {
+            domain: string;
+        };
+        _input_out: {
+            domain: string;
+        };
+        _output_in: {
+            success: true;
+            data?: undefined;
+        } | {
+            error: string;
+            success: false;
+        };
+        _output_out: {
+            success: true;
+            data?: undefined;
+        } | {
+            error: string;
+            success: false;
+        };
+    }, unknown>;
+    /**
+     * Get status of verified domain
+     */
+    getStatus: import("@trpc/server").BuildProcedure<"query", {
+        _config: import("@trpc/server").RootConfig<{
+            ctx: {};
+            meta: object;
+            errorShape: import("@trpc/server").DefaultErrorShape;
+            transformer: import("@trpc/server").DefaultDataTransformer;
+        }>;
+        _meta: object;
+        _ctx_out: {};
+        _input_in: {
+            domain: string;
+        };
+        _input_out: {
+            domain: string;
+        };
+        _output_in: {
+            data: {
+                status: "active" | "pending";
+            } | {
+                error: string;
+                status: "error";
+            };
+            success: true;
+        } | {
+            error: string;
+            success: false;
+        };
+        _output_out: {
+            data: {
+                status: "active" | "pending";
+            } | {
+                error: string;
+                status: "error";
+            };
+            success: true;
+        } | {
+            error: string;
+            success: false;
+        };
+    }, unknown>;
+}>;

package/lib/types/shared/shared-router.d.ts

@@ -260,6 +260,156 @@ export declare const sharedRouter: import("@trpc/server").CreateRouterInner<impo
             _output_out: typeof import("@trpc/server").unsetMarker;
         }, void>;
     }>;
+    domain: import("@trpc/server").CreateRouterInner<import("@trpc/server").RootConfig<{
+        ctx: {};
+        meta: object;
+        errorShape: import("@trpc/server").DefaultErrorShape;
+        transformer: import("@trpc/server").DefaultDataTransformer;
+    }>, {
+        create: import("@trpc/server").BuildProcedure<"mutation", {
+            _config: import("@trpc/server").RootConfig<{
+                ctx: {};
+                meta: object;
+                errorShape: import("@trpc/server").DefaultErrorShape;
+                transformer: import("@trpc/server").DefaultDataTransformer;
+            }>;
+            _meta: object;
+            _ctx_out: {};
+            _input_in: {
+                domain: string;
+                txtRecord: string;
+            };
+            _input_out: {
+                domain: string;
+                txtRecord: string;
+            };
+            _output_in: {
+                success: true;
+                data?: undefined;
+            } | {
+                error: string;
+                success: false;
+            };
+            _output_out: {
+                success: true;
+                data?: undefined;
+            } | {
+                error: string;
+                success: false;
+            };
+        }, unknown>;
+        refresh: import("@trpc/server").BuildProcedure<"mutation", {
+            _config: import("@trpc/server").RootConfig<{
+                ctx: {};
+                meta: object;
+                errorShape: import("@trpc/server").DefaultErrorShape;
+                transformer: import("@trpc/server").DefaultDataTransformer;
+            }>;
+            _meta: object;
+            _ctx_out: {};
+            _input_in: {
+                domain: string;
+            };
+            _input_out: {
+                domain: string;
+            };
+            _output_in: {
+                success: true;
+                data?: undefined;
+            } | {
+                error: string;
+                success: false;
+            };
+            _output_out: {
+                success: true;
+                data?: undefined;
+            } | {
+                error: string;
+                success: false;
+            };
+        }, unknown>;
+        getStatus: import("@trpc/server").BuildProcedure<"query", {
+            _config: import("@trpc/server").RootConfig<{
+                ctx: {};
+                meta: object;
+                errorShape: import("@trpc/server").DefaultErrorShape;
+                transformer: import("@trpc/server").DefaultDataTransformer;
+            }>;
+            _meta: object;
+            _ctx_out: {};
+            _input_in: {
+                domain: string;
+            };
+            _input_out: {
+                domain: string;
+            };
+            _output_in: {
+                data: {
+                    status: "active" | "pending";
+                } | {
+                    error: string;
+                    status: "error";
+                };
+                success: true;
+            } | {
+                error: string;
+                success: false;
+            };
+            _output_out: {
+                data: {
+                    status: "active" | "pending";
+                } | {
+                    error: string;
+                    status: "error";
+                };
+                success: true;
+            } | {
+                error: string;
+                success: false;
+            };
+        }, unknown>;
+    }>;
+    deployment: import("@trpc/server").CreateRouterInner<import("@trpc/server").RootConfig<{
+        ctx: {};
+        meta: object;
+        errorShape: import("@trpc/server").DefaultErrorShape;
+        transformer: import("@trpc/server").DefaultDataTransformer;
+    }>, {
+        publish: import("@trpc/server").BuildProcedure<"mutation", {
+            _config: import("@trpc/server").RootConfig<{
+                ctx: {};
+                meta: object;
+                errorShape: import("@trpc/server").DefaultErrorShape;
+                transformer: import("@trpc/server").DefaultDataTransformer;
+            }>;
+            _meta: object;
+            _ctx_out: {};
+            _input_in: {
+                buildId: string;
+                builderApiOrigin: string;
+                branchName: string;
+                projectDomainName: string;
+            };
+            _input_out: {
+                buildId: string;
+                builderApiOrigin: string;
+                branchName: string;
+                projectDomainName: string;
+            };
+            _output_in: {
+                success: true;
+            } | {
+                error: string;
+                success: false;
+            };
+            _output_out: {
+                success: true;
+            } | {
+                error: string;
+                success: false;
+            };
+        }, unknown>;
+    }>;
 }>;
 export type SharedRouter = typeof sharedRouter;
 export type TrpcInterfaceClient = ReturnType<typeof createTRPCProxyClient<SharedRouter>>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@webstudio-is/trpc-interface",
-  "version": "0.68.0",
+  "version": "0.69.0",
   "description": "Webstudio TRPC Interface",
   "author": "Webstudio <github@webstudio.is>",
   "homepage": "https://webstudio.is",
@@ -11,8 +11,8 @@
     "node-fetch": "2",
     "ts-custom-error": "^3.3.1",
     "uuid": "^9.0.0",
-    "zod": "^3.19.1",
-    "@webstudio-is/prisma-client": "^0.68.0"
+    "zod": "^3.21.4",
+    "@webstudio-is/prisma-client": "^0.69.0"
   },
   "devDependencies": {
     "@types/node": "^18.11.18",

package/src/authorize/project.server.ts

@@ -47,7 +47,7 @@ export const hasProjectPermit = async (
     const namespace = "Project";
 
     // Allow load production build env i.e. "published" site
-    if (props.permit === "view" && context.authorization.buildEnv === "prod") {
+    if (props.permit === "view" && context.authorization.isServiceCall) {
       return true;
     }
 

package/src/context/context.server.ts

@@ -15,14 +15,26 @@ type AuthorizationContext = {
   authToken: string | undefined;
 
   /**
-   * buildEnv==="prod" only if we are loading project with production build
+   * Allow service 2 service communications to skip authorization for view calls
    */
-  buildEnv: "dev" | "prod";
+  isServiceCall: boolean;
 
   // Pass trpcClient through context as only main app can initialize it
   authorizeTrpc: TrpcInterfaceClient["authorize"];
 };
 
+type DomainContext = {
+  domainTrpc: TrpcInterfaceClient["domain"];
+};
+
+type DeploymentContext = {
+  deploymentTrpc: TrpcInterfaceClient["deployment"];
+  env: {
+    BUILDER_ORIGIN: string;
+    BRANCH_NAME: string;
+  };
+};
+
 /**
  * AppContext is a global context that is passed to all trpc/api queries/mutations
  * "authorization" is made inside the namespace because eventually there will be
@@ -30,4 +42,6 @@ type AuthorizationContext = {
  */
 export type AppContext = {
   authorization: AuthorizationContext;
+  domain: DomainContext;
+  deployment: DeploymentContext;
 };

package/src/shared/deployment.ts

@@ -0,0 +1,35 @@
+import { z } from "zod";
+import { router, procedure } from "./trpc";
+
+const PublishInput = z.object({
+  // used to load build data from the builder see routes/rest.build.$buildId.ts
+  buildId: z.string(),
+  builderApiOrigin: z.string(),
+  // preview support
+  branchName: z.string(),
+  // action log helper (not used for deployment, but for action logs readablity)
+  projectDomainName: z.string(),
+});
+
+const Output = z.discriminatedUnion("success", [
+  z.object({
+    success: z.literal(true),
+  }),
+  z.object({
+    success: z.literal(false),
+    error: z.string(),
+  }),
+]);
+
+/**
+ * This is the ContentManagementService. It is currently used to publish content to a custom domain.
+ * In the future, additional methods, such as a 'preview' function, could be added.
+ **/
+export const deploymentRouter = router({
+  publish: procedure
+    .input(PublishInput)
+    .output(Output)
+    .mutation(async ({ input, ctx }) => {
+      return { success: false, error: "Not implemented" };
+    }),
+});

package/src/shared/domain.ts

@@ -0,0 +1,117 @@
+/**
+ * Localhost implementation of the dashboard trpc interface
+ * It's playground, and just emulates real 3rd party apis
+ */
+import { z } from "zod";
+import { router, procedure } from "./trpc";
+
+const CreateInput = z.object({ domain: z.string(), txtRecord: z.string() });
+const Input = z.object({ domain: z.string() });
+
+const createOutput = <T extends z.ZodType>(data: T) =>
+  z.discriminatedUnion("success", [
+    z.object({ success: z.literal(true), data }),
+    z.object({ success: z.literal(false), error: z.string() }),
+  ]);
+
+declare global {
+  // eslint-disable-next-line no-var
+  var dnsTxtEntries: Map<string, string>;
+  // eslint-disable-next-line no-var
+  var domainStates: Map<string, "active" | "pending" | "error">;
+}
+
+// Remix purges require module cache on every request in development,
+// this is the way to persist data between requests in development
+globalThis.dnsTxtEntries =
+  globalThis.dnsTxtEntries ?? new Map<string, string>();
+globalThis.domainStates =
+  globalThis.domainStates ?? new Map<string, "active" | "pending">();
+
+export const domainRouter = router({
+  /**
+   * Verify TXT record and add custom domain entry to DNS
+   */
+  create: procedure
+    .input(CreateInput)
+    .output(createOutput(z.optional(z.undefined())))
+    .mutation(async ({ input, ctx }) => {
+      const record = dnsTxtEntries.get(input.domain);
+      if (record !== input.txtRecord) {
+        // Return an error once then update the record
+        dnsTxtEntries.set(input.domain, input.txtRecord);
+
+        return {
+          success: false,
+          error: `TXT record does not match, expected "${
+            input.txtRecord
+          }" but got "${record ?? "undefined"}"`,
+        };
+      }
+
+      domainStates.set(input.domain, "pending");
+
+      return { success: true };
+    }),
+
+  refresh: procedure
+    .input(Input)
+    .output(createOutput(z.optional(z.undefined())))
+    .mutation(async ({ input, ctx }) => {
+      return { success: true };
+    }),
+  /**
+   * Get status of verified domain
+   */
+  getStatus: procedure
+    .input(Input)
+    .output(
+      createOutput(
+        z.discriminatedUnion("status", [
+          z.object({ status: z.enum(["active", "pending"]) }),
+          z.object({ status: z.enum(["error"]), error: z.string() }),
+        ])
+      )
+    )
+    .query(async ({ input, ctx }) => {
+      const domainState = domainStates.get(input.domain);
+
+      if (domainState === undefined) {
+        domainStates.set(input.domain, "pending");
+
+        return {
+          success: false,
+          error: `Domain ${input.domain} is not active`,
+        };
+      }
+
+      if (domainState === "active") {
+        setTimeout(() => {
+          domainStates.set(input.domain, "error");
+        });
+      }
+
+      if (domainState === "pending" || domainState === "error") {
+        setTimeout(() => {
+          domainStates.set(input.domain, "active");
+        }, 5000);
+      }
+
+      if (domainState === "error") {
+        return {
+          success: true,
+          data: {
+            status: "error",
+            error: "Domain cname verification failed",
+          },
+        };
+      }
+
+      return {
+        success: true,
+        data: {
+          status: domainState,
+        },
+      };
+    }),
+});

package/src/shared/shared-router.ts

@@ -1,9 +1,13 @@
 import type { createTRPCProxyClient } from "@trpc/client";
 import { router } from "./trpc";
 import { authorizationRouter } from "./authorization-router";
+import { domainRouter } from "./domain";
+import { deploymentRouter } from "./deployment";
 
 export const sharedRouter = router({
   authorize: authorizationRouter,
+  domain: domainRouter,
+  deployment: deploymentRouter,
 });
 
 export type SharedRouter = typeof sharedRouter;