@webstudio-is/trpc-interface 0.57.0 → 0.59.0

package/lib/cjs/shared/client.js

@@ -1,7 +1,9 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -15,12 +17,21 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var client_exports = {};
 __export(client_exports, {
   createTrpcProxyServiceClient: () => createTrpcProxyServiceClient
 });
 module.exports = __toCommonJS(client_exports);
+var import_node_fetch = __toESM(require("node-fetch"), 1);
 var import_client = require("@trpc/client");
 var import_shared_router = require("./shared-router");
 var import_trpc_caller_link = require("../trpc-caller-link");
@@ -29,6 +40,9 @@ const createTrpcProxyServiceClient = (options) => {
     const remoteClient = (0, import_client.createTRPCProxyClient)({
       links: [
         (0, import_client.httpBatchLink)({
+          // httpBatchLink uses lib.dom.d.ts's fetch type
+          // which is incompatible with node fetch type.
+          fetch: import_node_fetch.default,
           url: options.url,
           headers: () => ({
             Authorization: options.token,

package/lib/shared/client.js

@@ -1,3 +1,4 @@
+import fetch from "node-fetch";
 import { createTRPCProxyClient, httpBatchLink } from "@trpc/client";
 import {
   sharedRouter
@@ -8,6 +9,9 @@ const createTrpcProxyServiceClient = (options) => {
     const remoteClient = createTRPCProxyClient({
       links: [
         httpBatchLink({
+          // httpBatchLink uses lib.dom.d.ts's fetch type
+          // which is incompatible with node fetch type.
+          fetch,
           url: options.url,
           headers: () => ({
             Authorization: options.token,

package/lib/types/authorize/authorization-token.server.d.ts

@@ -0,0 +1,21 @@
+import type { AppContext } from "../context/context.server";
+/**
+ * For 3rd party authorization systems like Ory we need to register token for the project.
+ *
+ * We do that before the authorizationToken create (and out of the transaction),
+ * so in case of an error we will have just stale records of non existed projects in authorization system.
+ */
+export declare const registerToken: (props: {
+    projectId: string;
+    tokenId: string;
+    relation: "viewers" | "editors" | "builders";
+}, context: AppContext) => Promise<void>;
+export declare const patchToken: (props: {
+    projectId: string;
+    tokenId: string;
+}, prevRelation: "viewers" | "editors" | "builders", nextRelation: "viewers" | "editors" | "builders", context: AppContext) => Promise<void>;
+export declare const unregisterToken: (props: {
+    projectId: string;
+    tokenId: string;
+    relation: "viewers" | "editors";
+}, context: AppContext) => Promise<void>;

package/lib/types/authorize/project.server.d.ts

@@ -0,0 +1,25 @@
+import type { Project } from "@webstudio-is/prisma-client";
+import type { AuthPermit } from "../shared/authorization-router";
+import type { AppContext } from "../context/context.server";
+/**
+ * For 3rd party authorization systems like Ory we need to register the project owner.
+ *
+ * We do that before the project create (and out of the transaction),
+ * so in case of an error we will have just stale records of non existed projects in authorization system.
+ */
+export declare const registerProjectOwner: (props: {
+    projectId: string;
+}, context: AppContext) => Promise<void>;
+export declare const hasProjectPermit: (props: {
+    projectId: Project["id"];
+    permit: AuthPermit;
+}, context: AppContext) => Promise<boolean>;
+/**
+ * Returns the first allowed permit from the list or undefined if none is allowed
+ * @todo think about caching to authorizeTrpc.check.query
+ * batching check queries would help too https://github.com/ory/keto/issues/812
+ */
+export declare const getProjectPermit: <T extends "build" | "view" | "edit" | "own">(props: {
+    projectId: string;
+    permits: readonly T[];
+}, context: AppContext) => Promise<T | undefined>;

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

@@ -0,0 +1,28 @@
+import type { TrpcInterfaceClient } from "../shared/shared-router";
+/**
+ * All necessary parameters for Authorization
+ */
+type AuthorizationContext = {
+    /**
+     * userId of the current authenticated user
+     */
+    userId: string | undefined;
+    /**
+     * token URLSearchParams or hostname
+     */
+    authToken: string | undefined;
+    /**
+     * buildEnv==="prod" only if we are loading project with production build
+     */
+    buildEnv: "dev" | "prod";
+    authorizeTrpc: TrpcInterfaceClient["authorize"];
+};
+/**
+ * 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
+ * logging parameters, potentially "request" cache, etc.
+ */
+export type AppContext = {
+    authorization: AuthorizationContext;
+};
+export {};

package/lib/types/index.d.ts

@@ -0,0 +1 @@
+export * from "./index.server";

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

@@ -0,0 +1,6 @@
+export type { SharedRouter } from "./shared/shared-router";
+export { createTrpcProxyServiceClient } from "./shared/client";
+export type { AppContext } from "./context/context.server";
+export * as authorizeProject from "./authorize/project.server";
+export * as authorizeAuthorizationToken from "./authorize/authorization-token.server";
+export type { AuthPermit } from "./shared/authorization-router";

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

@@ -0,0 +1,276 @@
+import { z } from "zod";
+declare const AuthPermit: z.ZodEnum<["view", "edit", "build", "own"]>;
+export type AuthPermit = z.infer<typeof AuthPermit>;
+export declare const authorizationRouter: import("@trpc/server").CreateRouterInner<import("@trpc/server").RootConfig<{
+    ctx: {};
+    meta: object;
+    errorShape: import("@trpc/server").DefaultErrorShape;
+    transformer: import("@trpc/server").DefaultDataTransformer;
+}>, {
+    /**
+     * Relation expansion in authorize looks like a tree
+     *
+     * :#@Project:AliceProjectUUID#viewers
+     *   :#@Email:bob@bob.com#owner
+     *     :#@User:BobUUID️
+     *   :#@Token:LinkRandomSequence️
+     *
+     * We don't need the whole tree in UI and need only the leaf nodes.
+     * i.e. @User:BobUUID️, @Token:LinkRandomSequence️ and the root relation i.e "viewers"
+     */
+    expandLeafNodes: 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: {
+            id: string;
+            namespace: "Project";
+        };
+        _input_out: {
+            id: string;
+            namespace: "Project";
+        };
+        _output_in: {
+            id: string;
+            relation: "viewers" | "editors" | "builders" | "owners";
+            namespace: "User" | "Token" | "Email";
+        }[];
+        _output_out: {
+            id: string;
+            relation: "viewers" | "editors" | "builders" | "owners";
+            namespace: "User" | "Token" | "Email";
+        }[];
+    }, unknown>;
+    /**
+     * Check if subject has permit on the resource
+     */
+    check: 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: {
+            id: string;
+            namespace: "Project";
+            subjectSet: {
+                id: string;
+                namespace: "User" | "Token";
+            };
+            permit: "build" | "view" | "edit" | "own";
+        };
+        _input_out: {
+            id: string;
+            namespace: "Project";
+            subjectSet: {
+                id: string;
+                namespace: "User" | "Token";
+            };
+            permit: "build" | "view" | "edit" | "own";
+        };
+        _output_in: {
+            allowed: boolean;
+        };
+        _output_out: {
+            allowed: boolean;
+        };
+    }, unknown>;
+    /**
+     * In OSS we extract owner relation from the Project table, and the rest from the authorizationToken table
+     */
+    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: {
+            id: string;
+            relation: "viewers" | "editors" | "builders" | "owners";
+            namespace: "Project";
+            subjectSet: {
+                id: string;
+                namespace: "User";
+            } | {
+                id: string;
+                namespace: "Token";
+            } | {
+                id: string;
+                relation: "owners";
+                namespace: "Email";
+            };
+        } | {
+            id: string;
+            relation: "owners";
+            namespace: "Email";
+            subjectSet: {
+                id: string;
+                namespace: "User";
+            };
+        };
+        _input_out: {
+            id: string;
+            relation: "viewers" | "editors" | "builders" | "owners";
+            namespace: "Project";
+            subjectSet: {
+                id: string;
+                namespace: "User";
+            } | {
+                id: string;
+                namespace: "Token";
+            } | {
+                id: string;
+                relation: "owners";
+                namespace: "Email";
+            };
+        } | {
+            id: string;
+            relation: "owners";
+            namespace: "Email";
+            subjectSet: {
+                id: string;
+                namespace: "User";
+            };
+        };
+        _output_in: typeof import("@trpc/server").unsetMarker;
+        _output_out: typeof import("@trpc/server").unsetMarker;
+    }, void>;
+    delete: 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: {
+            id: string;
+            relation: "viewers" | "editors" | "builders" | "owners";
+            namespace: "Project";
+            subjectSet: {
+                id: string;
+                namespace: "User";
+            } | {
+                id: string;
+                namespace: "Token";
+            } | {
+                id: string;
+                relation: "owners";
+                namespace: "Email";
+            };
+        } | {
+            id: string;
+            relation: "owners";
+            namespace: "Email";
+            subjectSet: {
+                id: string;
+                namespace: "User";
+            };
+        };
+        _input_out: {
+            id: string;
+            relation: "viewers" | "editors" | "builders" | "owners";
+            namespace: "Project";
+            subjectSet: {
+                id: string;
+                namespace: "User";
+            } | {
+                id: string;
+                namespace: "Token";
+            } | {
+                id: string;
+                relation: "owners";
+                namespace: "Email";
+            };
+        } | {
+            id: string;
+            relation: "owners";
+            namespace: "Email";
+            subjectSet: {
+                id: string;
+                namespace: "User";
+            };
+        };
+        _output_in: typeof import("@trpc/server").unsetMarker;
+        _output_out: typeof import("@trpc/server").unsetMarker;
+    }, void>;
+    patch: 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: {
+            action: "delete" | "insert";
+            relationTuple: {
+                id: string;
+                relation: "viewers" | "editors" | "builders" | "owners";
+                namespace: "Project";
+                subjectSet: {
+                    id: string;
+                    namespace: "User";
+                } | {
+                    id: string;
+                    namespace: "Token";
+                } | {
+                    id: string;
+                    relation: "owners";
+                    namespace: "Email";
+                };
+            } | {
+                id: string;
+                relation: "owners";
+                namespace: "Email";
+                subjectSet: {
+                    id: string;
+                    namespace: "User";
+                };
+            };
+        }[];
+        _input_out: {
+            action: "delete" | "insert";
+            relationTuple: {
+                id: string;
+                relation: "viewers" | "editors" | "builders" | "owners";
+                namespace: "Project";
+                subjectSet: {
+                    id: string;
+                    namespace: "User";
+                } | {
+                    id: string;
+                    namespace: "Token";
+                } | {
+                    id: string;
+                    relation: "owners";
+                    namespace: "Email";
+                };
+            } | {
+                id: string;
+                relation: "owners";
+                namespace: "Email";
+                subjectSet: {
+                    id: string;
+                    namespace: "User";
+                };
+            };
+        }[];
+        _output_in: typeof import("@trpc/server").unsetMarker;
+        _output_out: typeof import("@trpc/server").unsetMarker;
+    }, void>;
+}>;
+export {};

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

@@ -0,0 +1,8 @@
+import { type TrpcInterfaceClient } from "./shared-router";
+type SharedClientOptions = {
+    url: string;
+    token: string;
+    branchName: string | undefined;
+};
+export declare const createTrpcProxyServiceClient: (options?: SharedClientOptions | undefined) => TrpcInterfaceClient;
+export {};

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

@@ -0,0 +1,265 @@
+import type { createTRPCProxyClient } from "@trpc/client";
+export declare const sharedRouter: import("@trpc/server").CreateRouterInner<import("@trpc/server").RootConfig<{
+    ctx: {};
+    meta: object;
+    errorShape: import("@trpc/server").DefaultErrorShape;
+    transformer: import("@trpc/server").DefaultDataTransformer;
+}>, {
+    authorize: import("@trpc/server").CreateRouterInner<import("@trpc/server").RootConfig<{
+        ctx: {};
+        meta: object;
+        errorShape: import("@trpc/server").DefaultErrorShape;
+        transformer: import("@trpc/server").DefaultDataTransformer;
+    }>, {
+        expandLeafNodes: 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: {
+                id: string;
+                namespace: "Project";
+            };
+            _input_out: {
+                id: string;
+                namespace: "Project";
+            };
+            _output_in: {
+                id: string;
+                relation: "viewers" | "editors" | "builders" | "owners";
+                namespace: "User" | "Token" | "Email";
+            }[];
+            _output_out: {
+                id: string;
+                relation: "viewers" | "editors" | "builders" | "owners";
+                namespace: "User" | "Token" | "Email";
+            }[];
+        }, unknown>;
+        check: 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: {
+                id: string;
+                namespace: "Project";
+                subjectSet: {
+                    id: string;
+                    namespace: "User" | "Token";
+                };
+                permit: "build" | "view" | "edit" | "own";
+            };
+            _input_out: {
+                id: string;
+                namespace: "Project";
+                subjectSet: {
+                    id: string;
+                    namespace: "User" | "Token";
+                };
+                permit: "build" | "view" | "edit" | "own";
+            };
+            _output_in: {
+                allowed: boolean;
+            };
+            _output_out: {
+                allowed: boolean;
+            };
+        }, unknown>;
+        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: {
+                id: string;
+                relation: "viewers" | "editors" | "builders" | "owners";
+                namespace: "Project";
+                subjectSet: {
+                    id: string;
+                    namespace: "User";
+                } | {
+                    id: string;
+                    namespace: "Token";
+                } | {
+                    id: string;
+                    relation: "owners";
+                    namespace: "Email";
+                };
+            } | {
+                id: string;
+                relation: "owners";
+                namespace: "Email";
+                subjectSet: {
+                    id: string;
+                    namespace: "User";
+                };
+            };
+            _input_out: {
+                id: string;
+                relation: "viewers" | "editors" | "builders" | "owners";
+                namespace: "Project";
+                subjectSet: {
+                    id: string;
+                    namespace: "User";
+                } | {
+                    id: string;
+                    namespace: "Token";
+                } | {
+                    id: string;
+                    relation: "owners";
+                    namespace: "Email";
+                };
+            } | {
+                id: string;
+                relation: "owners";
+                namespace: "Email";
+                subjectSet: {
+                    id: string;
+                    namespace: "User";
+                };
+            };
+            _output_in: typeof import("@trpc/server").unsetMarker;
+            _output_out: typeof import("@trpc/server").unsetMarker;
+        }, void>;
+        delete: 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: {
+                id: string;
+                relation: "viewers" | "editors" | "builders" | "owners";
+                namespace: "Project";
+                subjectSet: {
+                    id: string;
+                    namespace: "User";
+                } | {
+                    id: string;
+                    namespace: "Token";
+                } | {
+                    id: string;
+                    relation: "owners";
+                    namespace: "Email";
+                };
+            } | {
+                id: string;
+                relation: "owners";
+                namespace: "Email";
+                subjectSet: {
+                    id: string;
+                    namespace: "User";
+                };
+            };
+            _input_out: {
+                id: string;
+                relation: "viewers" | "editors" | "builders" | "owners";
+                namespace: "Project";
+                subjectSet: {
+                    id: string;
+                    namespace: "User";
+                } | {
+                    id: string;
+                    namespace: "Token";
+                } | {
+                    id: string;
+                    relation: "owners";
+                    namespace: "Email";
+                };
+            } | {
+                id: string;
+                relation: "owners";
+                namespace: "Email";
+                subjectSet: {
+                    id: string;
+                    namespace: "User";
+                };
+            };
+            _output_in: typeof import("@trpc/server").unsetMarker;
+            _output_out: typeof import("@trpc/server").unsetMarker;
+        }, void>;
+        patch: 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: {
+                action: "delete" | "insert";
+                relationTuple: {
+                    id: string;
+                    relation: "viewers" | "editors" | "builders" | "owners";
+                    namespace: "Project";
+                    subjectSet: {
+                        id: string;
+                        namespace: "User";
+                    } | {
+                        id: string;
+                        namespace: "Token";
+                    } | {
+                        id: string;
+                        relation: "owners";
+                        namespace: "Email";
+                    };
+                } | {
+                    id: string;
+                    relation: "owners";
+                    namespace: "Email";
+                    subjectSet: {
+                        id: string;
+                        namespace: "User";
+                    };
+                };
+            }[];
+            _input_out: {
+                action: "delete" | "insert";
+                relationTuple: {
+                    id: string;
+                    relation: "viewers" | "editors" | "builders" | "owners";
+                    namespace: "Project";
+                    subjectSet: {
+                        id: string;
+                        namespace: "User";
+                    } | {
+                        id: string;
+                        namespace: "Token";
+                    } | {
+                        id: string;
+                        relation: "owners";
+                        namespace: "Email";
+                    };
+                } | {
+                    id: string;
+                    relation: "owners";
+                    namespace: "Email";
+                    subjectSet: {
+                        id: string;
+                        namespace: "User";
+                    };
+                };
+            }[];
+            _output_in: typeof import("@trpc/server").unsetMarker;
+            _output_out: typeof import("@trpc/server").unsetMarker;
+        }, void>;
+    }>;
+}>;
+export type SharedRouter = typeof sharedRouter;
+export type TrpcInterfaceClient = ReturnType<typeof createTRPCProxyClient<SharedRouter>>;

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

@@ -0,0 +1,48 @@
+import { type inferAsyncReturnType } from "@trpc/server";
+export declare const createContext: () => Promise<{}>;
+export type Context = inferAsyncReturnType<typeof createContext>;
+export declare const router: <TProcRouterRecord extends import("@trpc/server").ProcedureRouterRecord>(procedures: TProcRouterRecord) => import("@trpc/server").CreateRouterInner<import("@trpc/server").RootConfig<{
+    ctx: {};
+    meta: object;
+    errorShape: import("@trpc/server").DefaultErrorShape;
+    transformer: import("@trpc/server").DefaultDataTransformer;
+}>, TProcRouterRecord>, procedure: import("@trpc/server").ProcedureBuilder<{
+    _config: import("@trpc/server").RootConfig<{
+        ctx: {};
+        meta: object;
+        errorShape: import("@trpc/server").DefaultErrorShape;
+        transformer: import("@trpc/server").DefaultDataTransformer;
+    }>;
+    _ctx_out: {};
+    _input_in: typeof import("@trpc/server").unsetMarker;
+    _input_out: typeof import("@trpc/server").unsetMarker;
+    _output_in: typeof import("@trpc/server").unsetMarker;
+    _output_out: typeof import("@trpc/server").unsetMarker;
+    _meta: object;
+}>, middleware: <TNewParams extends import("@trpc/server").ProcedureParams<import("@trpc/server").AnyRootConfig, unknown, unknown, unknown, unknown, unknown, unknown>>(fn: import("@trpc/server").MiddlewareFunction<{
+    _config: import("@trpc/server").RootConfig<{
+        ctx: {};
+        meta: object;
+        errorShape: import("@trpc/server").DefaultErrorShape;
+        transformer: import("@trpc/server").DefaultDataTransformer;
+    }>;
+    _ctx_out: {};
+    _input_out: unknown;
+    _input_in: unknown;
+    _output_in: unknown;
+    _output_out: unknown;
+    _meta: object;
+}, TNewParams>) => import("@trpc/server").MiddlewareFunction<{
+    _config: import("@trpc/server").RootConfig<{
+        ctx: {};
+        meta: object;
+        errorShape: import("@trpc/server").DefaultErrorShape;
+        transformer: import("@trpc/server").DefaultDataTransformer;
+    }>;
+    _ctx_out: {};
+    _input_out: unknown;
+    _input_in: unknown;
+    _output_in: unknown;
+    _output_out: unknown;
+    _meta: object;
+}, TNewParams>;

package/lib/types/trpc-caller-link.d.ts

@@ -0,0 +1,16 @@
+import type { AnyRouter } from "@trpc/server";
+import { type TRPCLink } from "@trpc/client";
+type MemoryLinkOptions<TemplateRouter extends AnyRouter> = {
+    appRouter: TemplateRouter;
+    createContext?: () => TemplateRouter["_def"]["_config"]["$types"]["ctx"];
+};
+/**
+ * https://github.com/trpc/trpc/issues/3335
+ *
+ * createCaller and createTRPCProxyClient provides different interfaces,
+ * here we provide callerLink which can be used as a [trpc client link](https://trpc.io/docs/links)
+ * Allowing us to call router api without http but through createTRPCProxyClient interface
+ * See trpc-caller-link.test.ts for details
+ **/
+export declare const callerLink: <TemplateRouter extends AnyRouter>(opts: MemoryLinkOptions<TemplateRouter>) => TRPCLink<TemplateRouter>;
+export {};

package/lib/types/trpc-caller-link.test.d.ts

@@ -0,0 +1,49 @@
+type Context = {
+    someCtx: string;
+};
+export declare const router: <TProcRouterRecord extends import("@trpc/server").ProcedureRouterRecord>(procedures: TProcRouterRecord) => import("@trpc/server").CreateRouterInner<import("@trpc/server").RootConfig<{
+    ctx: Context;
+    meta: object;
+    errorShape: import("@trpc/server").DefaultErrorShape;
+    transformer: import("@trpc/server").DefaultDataTransformer;
+}>, TProcRouterRecord>, procedure: import("@trpc/server").ProcedureBuilder<{
+    _config: import("@trpc/server").RootConfig<{
+        ctx: Context;
+        meta: object;
+        errorShape: import("@trpc/server").DefaultErrorShape;
+        transformer: import("@trpc/server").DefaultDataTransformer;
+    }>;
+    _ctx_out: Context;
+    _input_in: typeof import("@trpc/server").unsetMarker;
+    _input_out: typeof import("@trpc/server").unsetMarker;
+    _output_in: typeof import("@trpc/server").unsetMarker;
+    _output_out: typeof import("@trpc/server").unsetMarker;
+    _meta: object;
+}>, middleware: <TNewParams extends import("@trpc/server").ProcedureParams<import("@trpc/server").AnyRootConfig, unknown, unknown, unknown, unknown, unknown, unknown>>(fn: import("@trpc/server").MiddlewareFunction<{
+    _config: import("@trpc/server").RootConfig<{
+        ctx: Context;
+        meta: object;
+        errorShape: import("@trpc/server").DefaultErrorShape;
+        transformer: import("@trpc/server").DefaultDataTransformer;
+    }>;
+    _ctx_out: Context;
+    _input_out: unknown;
+    _input_in: unknown;
+    _output_in: unknown;
+    _output_out: unknown;
+    _meta: object;
+}, TNewParams>) => import("@trpc/server").MiddlewareFunction<{
+    _config: import("@trpc/server").RootConfig<{
+        ctx: Context;
+        meta: object;
+        errorShape: import("@trpc/server").DefaultErrorShape;
+        transformer: import("@trpc/server").DefaultDataTransformer;
+    }>;
+    _ctx_out: Context;
+    _input_out: unknown;
+    _input_in: unknown;
+    _output_in: unknown;
+    _output_out: unknown;
+    _meta: object;
+}, TNewParams>;
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@webstudio-is/trpc-interface",
-  "version": "0.57.0",
+  "version": "0.59.0",
   "description": "Webstudio TRPC Interface",
   "author": "Webstudio <github@webstudio.is>",
   "homepage": "https://webstudio.is",
@@ -8,16 +8,17 @@
   "dependencies": {
     "@trpc/client": "^10.9.0",
     "@trpc/server": "^10.9.0",
+    "node-fetch": "2",
     "uuid": "^9.0.0",
     "zod": "^3.19.1",
-    "@webstudio-is/prisma-client": "^0.57.0"
+    "@webstudio-is/prisma-client": "^0.59.0"
   },
   "devDependencies": {
     "@types/node": "^18.11.18",
     "typescript": "5.0.3",
-    "@webstudio-is/jest-config": "^1.0.4",
+    "@webstudio-is/jest-config": "^1.0.5",
     "@webstudio-is/scripts": "^0.0.0",
-    "@webstudio-is/tsconfig": "^1.0.4"
+    "@webstudio-is/tsconfig": "^1.0.5"
   },
   "exports": {
     "./server": {
@@ -39,7 +40,7 @@
     "checks": "pnpm typecheck && pnpm lint",
     "dev": "build-package --watch",
     "build": "build-package",
-    "dts": "tsc",
+    "dts": "tsc --declarationDir lib/types",
     "lint": "eslint ./src --ext .ts,.tsx --max-warnings 0"
   }
 }

package/src/shared/client.ts

@@ -1,3 +1,4 @@
+import fetch from "node-fetch";
 import { createTRPCProxyClient, httpBatchLink } from "@trpc/client";
 import {
   sharedRouter,
@@ -19,6 +20,9 @@ export const createTrpcProxyServiceClient = (
     const remoteClient = createTRPCProxyClient<SharedRouter>({
       links: [
         httpBatchLink({
+          // httpBatchLink uses lib.dom.d.ts's fetch type
+          // which is incompatible with node fetch type.
+          fetch: fetch as never,
           url: options.url,
           headers: () => ({
             Authorization: options.token,