@meteor-vite/plugin-zodern-relay 1.0.1 → 1.0.2

package/README.md

@@ -4,10 +4,6 @@ This is a Vite compatability package for
 [`zodern:relay`](https://github.com/zodern/meteor-relay#readme) - type safe
 [Meteor](https://meteor.com/) methods and publications.
 
-> [!IMPORTANT]
-> This plugin is not yet fully complete. Methods and publications imported by your client will not be omitted from
-> your client bundle like it would when using the `@zodern/babel-plugin-meteor-relay` plugin.
-
 This plugin acts as partial replacement for the Babel `@zodern/babel-plugin-meteor-relay` plugin required by 
 `zodern:relay`. You still need the Babel plugin as it might still be required on the server.
 
@@ -18,7 +14,7 @@ npm i -D @meteor-vite/plugin-zodern-relay
 ```
 
 ## Configuration
-Add the plugin to your Vite config and you're all set. There are no configuration options.
+Add the plugin to your Vite config and you're all set. If your methods and publications reside outside of `imports/api/<methods|publications>`, specify those paths when calling the plugin.
 ```ts
 // vite.config.ts
 import zodernRelay from '@meteor-vite/plugin-zodern-relay';
@@ -29,7 +25,21 @@ export default defineConfig({
         meteor({
             clientEntry: '...',
         }),
-        zodernRelay(),
+        zodernRelay({
+            directories: {
+                /**
+                 * Path to directories where your zodern:relay methods live
+                 * @default ['./imports/methods']
+                 */
+                methods: ['./imports/methods'],
+                
+                /**
+                 * Path to the directories where your zodern:relay publications live.
+                 * @default ['./imports/publications']
+                 */
+                publications: ['./imports/publications'],
+            }
+        }),
     ]
 })
 ```

package/dist/Plugin.d.mts

@@ -1,5 +1,19 @@
 import { Plugin } from 'vite';
 
-declare function zodernRelay(): Promise<Plugin>;
+declare function zodernRelay(options?: Options): Promise<Plugin>;
+interface Options {
+    directories?: {
+        /**
+         * Path to directories where your zodern:relay methods live
+         * @default ['./imports/methods']
+         */
+        methods?: string[];
+        /**
+         * Path to the directories where your zodern:relay publications live.
+         * @default ['./imports/publications']
+         */
+        publications?: string[];
+    };
+}
 
-export { zodernRelay as default };
+export { type Options, zodernRelay as default };

package/dist/Plugin.d.ts

@@ -1,5 +1,19 @@
 import { Plugin } from 'vite';
 
-declare function zodernRelay(): Promise<Plugin>;
+declare function zodernRelay(options?: Options): Promise<Plugin>;
+interface Options {
+    directories?: {
+        /**
+         * Path to directories where your zodern:relay methods live
+         * @default ['./imports/methods']
+         */
+        methods?: string[];
+        /**
+         * Path to the directories where your zodern:relay publications live.
+         * @default ['./imports/publications']
+         */
+        publications?: string[];
+    };
+}
 
-export { zodernRelay as default };
+export { type Options, zodernRelay as default };

package/dist/Plugin.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,6 +17,14 @@ 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);
 
 // src/Plugin.ts
@@ -23,22 +33,59 @@ __export(Plugin_exports, {
   default: () => zodernRelay
 });
 module.exports = __toCommonJS(Plugin_exports);
-var sourceModule = "meteor/zodern:relay";
-var stubModule = "@meteor-vite/zodern-relay/stubs/relay-client";
-async function zodernRelay() {
+var import_core = require("@babel/core");
+var import_fs = __toESM(require("fs"));
+var import_path = __toESM(require("path"));
+var cwd = process.cwd();
+async function zodernRelay(options) {
+  const config = {
+    directories: {
+      methods: options?.directories?.methods || ["./imports/methods"],
+      publications: options?.directories?.publications || ["./imports/publications"]
+    }
+  };
+  const directories = [
+    ...config.directories.methods.map((path) => ["methods", import_path.default.relative(cwd, path)]),
+    ...config.directories.publications.map((path) => ["publications", import_path.default.relative(cwd, path)])
+  ];
+  function resolveRelay(id) {
+    const relativePath = import_path.default.relative(cwd, id);
+    for (const [type, directory] of directories) {
+      if (!relativePath.startsWith(directory)) {
+        continue;
+      }
+      return {
+        id,
+        type,
+        relativePath
+      };
+    }
+  }
   return {
     name: "zodern-relay",
-    resolveId(id) {
-      if (!id.startsWith(sourceModule)) {
+    async load(filename) {
+      const relay = resolveRelay(filename || "");
+      if (!relay) {
         return;
       }
-      return `\0${id}`;
-    },
-    load(id) {
-      if (!id.startsWith(`\0${sourceModule}`)) {
+      const code = import_fs.default.readFileSync(filename, "utf-8");
+      const transform = await (0, import_core.transformAsync)(code, {
+        configFile: false,
+        babelrc: false,
+        filename,
+        plugins: ["@zodern/babel-plugin-meteor-relay"],
+        caller: {
+          name: "@meteor-vite/plugin-zodern-relay",
+          // @ts-expect-error No type definition for this, but it's required by the Babel plugin.
+          arch: "web.browser.vite"
+        }
+      });
+      if (!transform) {
         return;
       }
-      return `export * from ${JSON.stringify(stubModule)}`;
+      return {
+        code: transform.code ?? ""
+      };
     }
   };
 }

package/dist/Plugin.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/Plugin.ts"],"sourcesContent":["import type { Plugin } from 'vite';\n\nconst sourceModule = 'meteor/zodern:relay';\nconst stubModule = '@meteor-vite/zodern-relay/stubs/relay-client';\n\nexport default async function zodernRelay(): Promise<Plugin> {\n    return {\n        name: 'zodern-relay',\n        resolveId(id) {\n            if (!id.startsWith(sourceModule)) {\n                return;\n            }\n            return `\\0${id}`;\n        },\n        load(id) {\n            if (!id.startsWith(`\\0${sourceModule}`)) {\n                return;\n            }\n            \n            // language=typescript\n            return `export * from ${JSON.stringify(stubModule)}`;\n        }\n    }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAEA,IAAM,eAAe;AACrB,IAAM,aAAa;AAEnB,eAAO,cAAsD;AACzD,SAAO;AAAA,IACH,MAAM;AAAA,IACN,UAAU,IAAI;AACV,UAAI,CAAC,GAAG,WAAW,YAAY,GAAG;AAC9B;AAAA,MACJ;AACA,aAAO,KAAK,EAAE;AAAA,IAClB;AAAA,IACA,KAAK,IAAI;AACL,UAAI,CAAC,GAAG,WAAW,KAAK,YAAY,EAAE,GAAG;AACrC;AAAA,MACJ;AAGA,aAAO,iBAAiB,KAAK,UAAU,UAAU,CAAC;AAAA,IACtD;AAAA,EACJ;AACJ;","names":[]}
+{"version":3,"sources":["../src/Plugin.ts"],"sourcesContent":["import { transformAsync } from '@babel/core';\nimport FS from 'fs';\nimport Path from 'path';\nimport { type Plugin } from 'vite';\n\nconst cwd = process.cwd();\n\nexport default async function zodernRelay(options?: Options): Promise<Plugin> {\n    const config = {\n        directories: {\n            methods: options?.directories?.methods || ['./imports/methods'],\n            publications: options?.directories?.publications || ['./imports/publications'],\n        }\n    } satisfies Options;\n    \n    const directories = [\n        ...config.directories.methods.map((path) => ['methods', Path.relative(cwd, path)]),\n        ...config.directories.publications.map((path) => ['publications', Path.relative(cwd, path)])\n    ] as [RelayInfo['type'], string][];\n    \n    function resolveRelay(id: string): RelayInfo | undefined {\n        const relativePath = Path.relative(cwd, id);\n        for (const [type, directory] of directories) {\n            if (!relativePath.startsWith(directory)) {\n                continue;\n            }\n            return {\n                id,\n                type,\n                relativePath,\n            }\n        }\n    }\n    \n    return {\n        name: 'zodern-relay',\n        async load(filename) {\n            const relay = resolveRelay(filename || '');\n            if (!relay) {\n                return;\n            }\n            const code = FS.readFileSync(filename, 'utf-8');\n            const transform = await transformAsync(code, {\n                configFile: false,\n                babelrc: false,\n                filename,\n                plugins: ['@zodern/babel-plugin-meteor-relay'],\n                caller: {\n                    name: '@meteor-vite/plugin-zodern-relay',\n                    \n                    // @ts-expect-error No type definition for this, but it's required by the Babel plugin.\n                    arch: 'web.browser.vite',\n                }\n            });\n            \n            if (!transform) {\n                return;\n            }\n            \n            return {\n                code: transform.code ?? '',\n            }\n        }\n    }\n    \n    \n}\nexport interface Options {\n    directories?: {\n        /**\n         * Path to directories where your zodern:relay methods live\n         * @default ['./imports/methods']\n         */\n        methods?: string[],\n        \n        /**\n         * Path to the directories where your zodern:relay publications live.\n         * @default ['./imports/publications']\n         */\n        publications?: string[],\n    }\n}\n\ntype RelayInfo = {\n    type: 'methods' | 'publications';\n    id: string;\n    relativePath: string;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,kBAA+B;AAC/B,gBAAe;AACf,kBAAiB;AAGjB,IAAM,MAAM,QAAQ,IAAI;AAExB,eAAO,YAAmC,SAAoC;AAC1E,QAAM,SAAS;AAAA,IACX,aAAa;AAAA,MACT,SAAS,SAAS,aAAa,WAAW,CAAC,mBAAmB;AAAA,MAC9D,cAAc,SAAS,aAAa,gBAAgB,CAAC,wBAAwB;AAAA,IACjF;AAAA,EACJ;AAEA,QAAM,cAAc;AAAA,IAChB,GAAG,OAAO,YAAY,QAAQ,IAAI,CAAC,SAAS,CAAC,WAAW,YAAAA,QAAK,SAAS,KAAK,IAAI,CAAC,CAAC;AAAA,IACjF,GAAG,OAAO,YAAY,aAAa,IAAI,CAAC,SAAS,CAAC,gBAAgB,YAAAA,QAAK,SAAS,KAAK,IAAI,CAAC,CAAC;AAAA,EAC/F;AAEA,WAAS,aAAa,IAAmC;AACrD,UAAM,eAAe,YAAAA,QAAK,SAAS,KAAK,EAAE;AAC1C,eAAW,CAAC,MAAM,SAAS,KAAK,aAAa;AACzC,UAAI,CAAC,aAAa,WAAW,SAAS,GAAG;AACrC;AAAA,MACJ;AACA,aAAO;AAAA,QACH;AAAA,QACA;AAAA,QACA;AAAA,MACJ;AAAA,IACJ;AAAA,EACJ;AAEA,SAAO;AAAA,IACH,MAAM;AAAA,IACN,MAAM,KAAK,UAAU;AACjB,YAAM,QAAQ,aAAa,YAAY,EAAE;AACzC,UAAI,CAAC,OAAO;AACR;AAAA,MACJ;AACA,YAAM,OAAO,UAAAC,QAAG,aAAa,UAAU,OAAO;AAC9C,YAAM,YAAY,UAAM,4BAAe,MAAM;AAAA,QACzC,YAAY;AAAA,QACZ,SAAS;AAAA,QACT;AAAA,QACA,SAAS,CAAC,mCAAmC;AAAA,QAC7C,QAAQ;AAAA,UACJ,MAAM;AAAA;AAAA,UAGN,MAAM;AAAA,QACV;AAAA,MACJ,CAAC;AAED,UAAI,CAAC,WAAW;AACZ;AAAA,MACJ;AAEA,aAAO;AAAA,QACH,MAAM,UAAU,QAAQ;AAAA,MAC5B;AAAA,IACJ;AAAA,EACJ;AAGJ;","names":["Path","FS"]}

package/dist/Plugin.mjs

@@ -1,20 +1,57 @@
 // src/Plugin.ts
-var sourceModule = "meteor/zodern:relay";
-var stubModule = "@meteor-vite/zodern-relay/stubs/relay-client";
-async function zodernRelay() {
+import { transformAsync } from "@babel/core";
+import FS from "fs";
+import Path from "path";
+var cwd = process.cwd();
+async function zodernRelay(options) {
+  const config = {
+    directories: {
+      methods: options?.directories?.methods || ["./imports/methods"],
+      publications: options?.directories?.publications || ["./imports/publications"]
+    }
+  };
+  const directories = [
+    ...config.directories.methods.map((path) => ["methods", Path.relative(cwd, path)]),
+    ...config.directories.publications.map((path) => ["publications", Path.relative(cwd, path)])
+  ];
+  function resolveRelay(id) {
+    const relativePath = Path.relative(cwd, id);
+    for (const [type, directory] of directories) {
+      if (!relativePath.startsWith(directory)) {
+        continue;
+      }
+      return {
+        id,
+        type,
+        relativePath
+      };
+    }
+  }
   return {
     name: "zodern-relay",
-    resolveId(id) {
-      if (!id.startsWith(sourceModule)) {
+    async load(filename) {
+      const relay = resolveRelay(filename || "");
+      if (!relay) {
         return;
       }
-      return `\0${id}`;
-    },
-    load(id) {
-      if (!id.startsWith(`\0${sourceModule}`)) {
+      const code = FS.readFileSync(filename, "utf-8");
+      const transform = await transformAsync(code, {
+        configFile: false,
+        babelrc: false,
+        filename,
+        plugins: ["@zodern/babel-plugin-meteor-relay"],
+        caller: {
+          name: "@meteor-vite/plugin-zodern-relay",
+          // @ts-expect-error No type definition for this, but it's required by the Babel plugin.
+          arch: "web.browser.vite"
+        }
+      });
+      if (!transform) {
         return;
       }
-      return `export * from ${JSON.stringify(stubModule)}`;
+      return {
+        code: transform.code ?? ""
+      };
     }
   };
 }

package/dist/Plugin.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/Plugin.ts"],"sourcesContent":["import type { Plugin } from 'vite';\n\nconst sourceModule = 'meteor/zodern:relay';\nconst stubModule = '@meteor-vite/zodern-relay/stubs/relay-client';\n\nexport default async function zodernRelay(): Promise<Plugin> {\n    return {\n        name: 'zodern-relay',\n        resolveId(id) {\n            if (!id.startsWith(sourceModule)) {\n                return;\n            }\n            return `\\0${id}`;\n        },\n        load(id) {\n            if (!id.startsWith(`\\0${sourceModule}`)) {\n                return;\n            }\n            \n            // language=typescript\n            return `export * from ${JSON.stringify(stubModule)}`;\n        }\n    }\n}\n"],"mappings":";AAEA,IAAM,eAAe;AACrB,IAAM,aAAa;AAEnB,eAAO,cAAsD;AACzD,SAAO;AAAA,IACH,MAAM;AAAA,IACN,UAAU,IAAI;AACV,UAAI,CAAC,GAAG,WAAW,YAAY,GAAG;AAC9B;AAAA,MACJ;AACA,aAAO,KAAK,EAAE;AAAA,IAClB;AAAA,IACA,KAAK,IAAI;AACL,UAAI,CAAC,GAAG,WAAW,KAAK,YAAY,EAAE,GAAG;AACrC;AAAA,MACJ;AAGA,aAAO,iBAAiB,KAAK,UAAU,UAAU,CAAC;AAAA,IACtD;AAAA,EACJ;AACJ;","names":[]}
+{"version":3,"sources":["../src/Plugin.ts"],"sourcesContent":["import { transformAsync } from '@babel/core';\nimport FS from 'fs';\nimport Path from 'path';\nimport { type Plugin } from 'vite';\n\nconst cwd = process.cwd();\n\nexport default async function zodernRelay(options?: Options): Promise<Plugin> {\n    const config = {\n        directories: {\n            methods: options?.directories?.methods || ['./imports/methods'],\n            publications: options?.directories?.publications || ['./imports/publications'],\n        }\n    } satisfies Options;\n    \n    const directories = [\n        ...config.directories.methods.map((path) => ['methods', Path.relative(cwd, path)]),\n        ...config.directories.publications.map((path) => ['publications', Path.relative(cwd, path)])\n    ] as [RelayInfo['type'], string][];\n    \n    function resolveRelay(id: string): RelayInfo | undefined {\n        const relativePath = Path.relative(cwd, id);\n        for (const [type, directory] of directories) {\n            if (!relativePath.startsWith(directory)) {\n                continue;\n            }\n            return {\n                id,\n                type,\n                relativePath,\n            }\n        }\n    }\n    \n    return {\n        name: 'zodern-relay',\n        async load(filename) {\n            const relay = resolveRelay(filename || '');\n            if (!relay) {\n                return;\n            }\n            const code = FS.readFileSync(filename, 'utf-8');\n            const transform = await transformAsync(code, {\n                configFile: false,\n                babelrc: false,\n                filename,\n                plugins: ['@zodern/babel-plugin-meteor-relay'],\n                caller: {\n                    name: '@meteor-vite/plugin-zodern-relay',\n                    \n                    // @ts-expect-error No type definition for this, but it's required by the Babel plugin.\n                    arch: 'web.browser.vite',\n                }\n            });\n            \n            if (!transform) {\n                return;\n            }\n            \n            return {\n                code: transform.code ?? '',\n            }\n        }\n    }\n    \n    \n}\nexport interface Options {\n    directories?: {\n        /**\n         * Path to directories where your zodern:relay methods live\n         * @default ['./imports/methods']\n         */\n        methods?: string[],\n        \n        /**\n         * Path to the directories where your zodern:relay publications live.\n         * @default ['./imports/publications']\n         */\n        publications?: string[],\n    }\n}\n\ntype RelayInfo = {\n    type: 'methods' | 'publications';\n    id: string;\n    relativePath: string;\n};\n"],"mappings":";AAAA,SAAS,sBAAsB;AAC/B,OAAO,QAAQ;AACf,OAAO,UAAU;AAGjB,IAAM,MAAM,QAAQ,IAAI;AAExB,eAAO,YAAmC,SAAoC;AAC1E,QAAM,SAAS;AAAA,IACX,aAAa;AAAA,MACT,SAAS,SAAS,aAAa,WAAW,CAAC,mBAAmB;AAAA,MAC9D,cAAc,SAAS,aAAa,gBAAgB,CAAC,wBAAwB;AAAA,IACjF;AAAA,EACJ;AAEA,QAAM,cAAc;AAAA,IAChB,GAAG,OAAO,YAAY,QAAQ,IAAI,CAAC,SAAS,CAAC,WAAW,KAAK,SAAS,KAAK,IAAI,CAAC,CAAC;AAAA,IACjF,GAAG,OAAO,YAAY,aAAa,IAAI,CAAC,SAAS,CAAC,gBAAgB,KAAK,SAAS,KAAK,IAAI,CAAC,CAAC;AAAA,EAC/F;AAEA,WAAS,aAAa,IAAmC;AACrD,UAAM,eAAe,KAAK,SAAS,KAAK,EAAE;AAC1C,eAAW,CAAC,MAAM,SAAS,KAAK,aAAa;AACzC,UAAI,CAAC,aAAa,WAAW,SAAS,GAAG;AACrC;AAAA,MACJ;AACA,aAAO;AAAA,QACH;AAAA,QACA;AAAA,QACA;AAAA,MACJ;AAAA,IACJ;AAAA,EACJ;AAEA,SAAO;AAAA,IACH,MAAM;AAAA,IACN,MAAM,KAAK,UAAU;AACjB,YAAM,QAAQ,aAAa,YAAY,EAAE;AACzC,UAAI,CAAC,OAAO;AACR;AAAA,MACJ;AACA,YAAM,OAAO,GAAG,aAAa,UAAU,OAAO;AAC9C,YAAM,YAAY,MAAM,eAAe,MAAM;AAAA,QACzC,YAAY;AAAA,QACZ,SAAS;AAAA,QACT;AAAA,QACA,SAAS,CAAC,mCAAmC;AAAA,QAC7C,QAAQ;AAAA,UACJ,MAAM;AAAA;AAAA,UAGN,MAAM;AAAA,QACV;AAAA,MACJ,CAAC;AAED,UAAI,CAAC,WAAW;AACZ;AAAA,MACJ;AAEA,aAAO;AAAA,QACH,MAAM,UAAU,QAAQ;AAAA,MAC5B;AAAA,IACJ;AAAA,EACJ;AAGJ;","names":[]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meteor-vite/plugin-zodern-relay",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "description": "Vite compatability plugin for zodern:relay - typed Meteor methods and publications",
   "main": "dist/Plugin.js",
   "exports": {
@@ -40,8 +40,13 @@
     "url": "https://github.com/JorgenVatle/meteor-vite"
   },
   "devDependencies": {
+    "@types/babel__core": "^7.20.5",
     "tsup": "^8.0.2",
     "typescript": "^5.4.2",
     "vite": "^5.1.6"
+  },
+  "peerDependencies": {
+    "@babel/core": "^7.0.0",
+    "vite": ">=3.0.0"
   }
 }

package/src/Plugin.ts

@@ -1,24 +1,88 @@
-import type { Plugin } from 'vite';
+import { transformAsync } from '@babel/core';
+import FS from 'fs';
+import Path from 'path';
+import { type Plugin } from 'vite';
 
-const sourceModule = 'meteor/zodern:relay';
-const stubModule = '@meteor-vite/zodern-relay/stubs/relay-client';
+const cwd = process.cwd();
 
-export default async function zodernRelay(): Promise<Plugin> {
+export default async function zodernRelay(options?: Options): Promise<Plugin> {
+    const config = {
+        directories: {
+            methods: options?.directories?.methods || ['./imports/methods'],
+            publications: options?.directories?.publications || ['./imports/publications'],
+        }
+    } satisfies Options;
+    
+    const directories = [
+        ...config.directories.methods.map((path) => ['methods', Path.relative(cwd, path)]),
+        ...config.directories.publications.map((path) => ['publications', Path.relative(cwd, path)])
+    ] as [RelayInfo['type'], string][];
+    
+    function resolveRelay(id: string): RelayInfo | undefined {
+        const relativePath = Path.relative(cwd, id);
+        for (const [type, directory] of directories) {
+            if (!relativePath.startsWith(directory)) {
+                continue;
+            }
+            return {
+                id,
+                type,
+                relativePath,
+            }
+        }
+    }
+    
     return {
         name: 'zodern-relay',
-        resolveId(id) {
-            if (!id.startsWith(sourceModule)) {
+        async load(filename) {
+            const relay = resolveRelay(filename || '');
+            if (!relay) {
                 return;
             }
-            return `\0${id}`;
-        },
-        load(id) {
-            if (!id.startsWith(`\0${sourceModule}`)) {
+            const code = FS.readFileSync(filename, 'utf-8');
+            const transform = await transformAsync(code, {
+                configFile: false,
+                babelrc: false,
+                filename,
+                plugins: ['@zodern/babel-plugin-meteor-relay'],
+                caller: {
+                    name: '@meteor-vite/plugin-zodern-relay',
+                    
+                    // @ts-expect-error No type definition for this, but it's required by the Babel plugin.
+                    arch: 'web.browser.vite',
+                }
+            });
+            
+            if (!transform) {
                 return;
             }
             
-            // language=typescript
-            return `export * from ${JSON.stringify(stubModule)}`;
+            return {
+                code: transform.code ?? '',
+            }
         }
     }
+    
+    
 }
+export interface Options {
+    directories?: {
+        /**
+         * Path to directories where your zodern:relay methods live
+         * @default ['./imports/methods']
+         */
+        methods?: string[],
+        
+        /**
+         * Path to the directories where your zodern:relay publications live.
+         * @default ['./imports/publications']
+         */
+        publications?: string[],
+    }
+}
+
+type RelayInfo = {
+    type: 'methods' | 'publications';
+    id: string;
+    relativePath: string;
+};

package/stubs/babel-plugin.js

@@ -0,0 +1,445 @@
+const { createHash } = require('crypto');
+const path = require('path');
+
+// If has a MemberExpression, returns the first call expression in its callee
+// Otherwise, returns the call expression
+function getFirstCallExpr(call) {
+  if (call.node.callee.type !== 'MemberExpression') {
+    return call;
+  }
+
+
+  if (
+    call.node.callee.object.type !== 'CallExpression'
+  ) {
+    return;
+  }
+
+  return call.get('callee.object');
+}
+
+module.exports = function (api) {
+  let t = api.types;
+
+  let caller;
+  api.caller(function (c) {
+    caller = c;
+  });
+
+  function createExport(exportName, callee, name, stub) {
+    let args = [
+      t.StringLiteral(name)
+    ];
+
+    if (stub) {
+      if (stub.type === 'ObjectMethod') {
+        stub = t.FunctionExpression(
+          null,
+          stub.node.params || [],
+          stub.node.body,
+          stub.node.generator,
+          stub.node.async
+        )
+      } else if (stub.type === 'ObjectProperty') {
+        stub = stub.node.value;
+      }
+      args.push(stub);
+    }
+
+    const declaration = t.CallExpression(
+      t.Identifier(callee),
+      args
+    );
+
+    if (exportName === null) {
+      return t.ExportDefaultDeclaration(
+        declaration
+      );
+    }
+
+    return t.ExportNamedDeclaration(
+      t.VariableDeclaration(
+        'const',
+        [t.VariableDeclarator(
+          t.Identifier(exportName),
+          declaration
+        )]
+      )
+    )
+  }
+
+  function getOrAddName(args, { exportName, filePath, isPub }) {
+    if (args[0].type !== 'ObjectExpression') {
+      return;
+    }
+
+    let obj = args[0];
+    let nameProperty = obj.properties.find((property) => {
+      if (property.key.type !== 'Identifier') {
+        return false;
+      }
+
+      if (property.key.name !== 'name') {
+        return false;
+      }
+
+      return property.value.type === 'StringLiteral';
+    });
+
+    if (nameProperty) {
+      return nameProperty.value.value;
+    }
+
+    let fileHash = 'M' + createHash('sha256')
+      .update(filePath)
+      .digest('hex')
+      .substring(0, 5);
+
+    let name = exportName;
+
+    if (name === null) {
+      let baseName = path.basename(filePath);
+      let lastDotIndex = baseName.lastIndexOf('.');
+      name = baseName.substring(0, lastDotIndex);
+    } else if (isPub && name.startsWith('subscribe')) {
+      name = exportName.substring('subscribe'.length);
+
+      if (name[0] !== name[0].toLowerCase()) {
+        name = `${name[0].toLowerCase()}${name.substring(1)}`
+      }
+    }
+
+    name += fileHash;
+
+    obj.properties.push(t.ObjectProperty(
+      t.Identifier('name'),
+      t.StringLiteral(name)
+    ));
+
+    return name;
+  }
+
+  // TODO: args should be a path instead of node
+  function findStubPropertyIndex(args) {
+    let obj = args[0];
+    let stubPropIndex = obj.properties.findIndex((property) => {
+      if (property.key.type !== 'Identifier') {
+        return false;
+      }
+
+      if (property.key.name !== 'stub') {
+        return false;
+      }
+
+      return true;
+    });
+    let stub = obj.properties[stubPropIndex];
+
+    if (!stub) {
+      return -1;
+    }
+
+    if (
+       stub.type === 'ObjectMethod' ||
+      stub.value.type === 'FunctionExpression' ||
+      stub.value.type === 'ArrowFunctionExpression'
+    ) {
+      return stubPropIndex;
+    }
+
+
+    if (stub.value.type !== 'BooleanLiteral') {
+      return -1;
+    }
+
+    if (stub.value.value !== true) {
+      return -1;
+    }
+
+    // stub is set to true - use the run function
+    return obj.properties.findIndex((property) => {
+      if (property.key.type !== 'Identifier') {
+        return false;
+      }
+
+      if (property.key.name !== 'run') {
+        return false;
+      }
+
+      return true;
+    });
+  }
+
+  let canHaveMethods = false;
+  let canHavePublications = false;
+  let createMethodName = null;
+  let createPublicationName = null;
+  let methods = [];
+  let publications = [];
+  let isServer = false;
+  let filePath = ''
+  let imports = Object.create(null);
+
+  return {
+    visitor: {
+      Program: {
+        enter(_, state) {
+          createMethodName = null;
+          createPublicationName = null;
+          methods = [];
+          publications = [];
+
+          let relPath = path
+            .relative(state.cwd, state.filename)
+            .split(path.sep)
+            .join(path.posix.sep);
+          filePath = relPath;
+
+          canHaveMethods = relPath.includes('/methods/') || relPath.startsWith('methods/');
+          canHavePublications = relPath.includes('/publications/') || relPath.startsWith('publications/');
+
+          isServer = caller.arch.startsWith('os.');
+
+          if (!canHaveMethods && !canHavePublications) {
+            return;
+          }
+        },
+        exit(path) {
+          if (isServer || !canHaveMethods && !canHavePublications) {
+            return;
+          }
+
+          if (methods.length === 0 && publications.length === 0) {
+            path.node.body = [];
+            return;
+          }
+
+          let body = [];
+
+          let importSpecifiers = [];
+          if (methods.length > 0) {
+            importSpecifiers.push(
+              t.ImportSpecifier(t.Identifier('_createClientMethod'), t.Identifier('_createClientMethod'))
+            );
+          }
+          if (publications.length > 0) {
+            importSpecifiers.push(
+              t.ImportSpecifier(t.Identifier('_createClientPublication'), t.Identifier('_createClientPublication'))
+            )
+          }
+
+          let importDecl = t.ImportDeclaration(
+            importSpecifiers,
+            t.StringLiteral('meteor/zodern:relay/client'),
+          );
+
+          body.push(importDecl);
+
+          methods.forEach(method => {
+            if (method.stub) {
+              let stubBody = method.stub.get('body').node ?
+                method.stub.get('body') : method.stub.get('value.body');
+              stubBody.traverse({
+                ReferencedIdentifier(subPath) {
+                  if (stubBody.scope.hasOwnBinding(subPath.node.name)) {
+                    return;
+                  }
+
+                  if (subPath.node.name in imports) {
+                    let importDesc = imports[subPath.node.name];
+
+                    let specifier;
+                    if (importDesc.type === 'ImportDefaultSpecifier') {
+                      specifier = t.ImportDefaultSpecifier(t.Identifier(subPath.node.name));
+                    } else if (importDesc.type === 'ImportNamespaceSpecifier') {
+                      specifier = t.ImportNamespaceSpecifier(t.Identifier(subPath.node.name));
+                    } else {
+                      specifier = t.ImportSpecifier(
+                        t.Identifier(importDesc.importName),
+                        t.Identifier(subPath.node.name)
+                      );
+                    }
+
+                    // TODO: we should preserve the original order of the imports
+                    body.push(t.ImportDeclaration(
+                      [ specifier ],
+                      t.StringLiteral(importDesc.source)
+                    ));
+                  }
+                }
+              });
+            }
+
+            body.push(
+              createExport(method.export, '_createClientMethod', method.name, method.stub)
+            );
+          });
+
+          publications.forEach(publication => {
+            body.push(
+              createExport(publication.export, '_createClientPublication', publication.name)
+            );
+          });
+
+          path.node.body = body;
+
+          return;
+        },
+      },
+      ImportDeclaration(path) {
+        path.node.specifiers.forEach(specifier => {
+          let type = specifier.type;
+          let hasImportName = type !== 'ImportDefaultSpecifier' &&
+            type !== 'ImportNamespaceSpecifier'
+          imports[specifier.local.name] = {
+            type,
+            importName: hasImportName ?
+              specifier.imported.name :
+              null,
+            source: path.node.source.value
+          };
+
+          if (!hasImportName) {
+            return;
+          }
+
+          if (canHaveMethods && specifier.imported.name === 'createMethod') {
+            createMethodName = specifier.local.name;
+          }
+          if (canHavePublications && specifier.imported.name === 'createPublication') {
+            createPublicationName = specifier.local.name;
+          }
+        });
+      },
+      ExportDefaultDeclaration(path) {
+        if (path.node.declaration.type !== 'CallExpression') {
+          return;
+        }
+
+        let call = getFirstCallExpr(path.get('declaration'));
+
+        if (!call) {
+          return;
+        }
+
+        if (
+          call.node.callee.name === createMethodName
+        ) {
+          let name = getOrAddName(call.node.arguments, {
+            exportName: null,
+            filePath,
+            isPub: false
+          });
+          if (name === undefined) {
+            throw new Error('Unable to find name for createMethod');
+          }
+          let stubPropIndex = findStubPropertyIndex(call.node.arguments);
+          let stub;
+          if (stubPropIndex > -1) {
+            stub = call.get(`arguments.0.properties.${stubPropIndex}`);
+          }
+
+          methods.push({
+            name: name,
+            export: null,
+            stub
+          });
+        }
+
+        if (
+          call.node.callee.name === createPublicationName
+        ) {
+          let name = getOrAddName(call.node.arguments, {
+            exportName: null,
+            filePath,
+            isPub: true
+          });
+          if (name === undefined) {
+            throw new Error('Unable to find name for createMethod');
+          }
+
+          publications.push({
+            name: name,
+            export: null
+          });
+        }
+      },
+      ExportNamedDeclaration(path) {
+        let declaration = path.get('declaration');
+
+        if (
+          // null when the code is something like "export { h };"
+          !declaration.node ||
+          declaration.isFunctionDeclaration()
+        ) {
+          return;
+        }
+
+        if (declaration.type == 'ClassDeclaration') {
+          return;
+        }
+
+        if (declaration.type !== 'VariableDeclaration') {
+          throw new Error(`export declarations of type ${declaration.type} are not supported`);
+        }
+
+        declaration.get('declarations').forEach(vDeclaration => {
+          if (!vDeclaration.isVariableDeclarator()) {
+            throw new Error(`Unsupported declaration type in VariableDeclaration: ${vDeclaration.node.type}`);
+          }
+
+          if (!vDeclaration.get('init').isCallExpression()) {
+            return;
+          }
+
+          let call = getFirstCallExpr(vDeclaration.get('init'));
+
+          if (!call) {
+            return;
+          }
+
+          if (
+            call.node.callee.name === createMethodName
+          ) {
+            let name = getOrAddName(call.node.arguments, {
+              exportName: vDeclaration.node.id.name,
+              filePath,
+              isPub: false
+            });
+            if (name === undefined) {
+              throw new Error('Unable to find name for createMethod');
+            }
+            let stubPropIndex = findStubPropertyIndex(call.node.arguments);
+            let stub;
+            if (stubPropIndex > -1) {
+              stub = call.get(`arguments.0.properties.${stubPropIndex}`);
+            }
+            methods.push({
+              name: name,
+              export: vDeclaration.node.id.name,
+              stub
+            });
+          }
+
+          if (
+            call.node.callee.name === createPublicationName
+          ) {
+            let name = getOrAddName(call.node.arguments, {
+              exportName: vDeclaration.node.id.name,
+              filePath,
+              isPub: true
+            });
+            if (name === undefined) {
+              throw new Error('Unable to find name for createMethod');
+            }
+
+            publications.push({
+              name: name,
+              export: vDeclaration.node.id.name
+            });
+          }
+        })
+      }
+    }
+  };
+}