theokit 0.48.13 → 0.50.0

package/dist/server-boundary-7VZQRPPX.js

@@ -0,0 +1,133 @@
+#!/usr/bin/env node
+import "tsx/esm";
+import {
+  resolveTheoRootDir
+} from "./chunk-FDOOBTXJ.js";
+import "./chunk-C62IZEJI.js";
+import "./chunk-5YPXXSYY.js";
+import "./chunk-HWBRS4DZ.js";
+import "./chunk-RPET332G.js";
+import "./chunk-7PM6K5EV.js";
+import "./chunk-2AMLGJJA.js";
+import "./chunk-KUZVRJ7M.js";
+import "./chunk-EVZKNA2W.js";
+import {
+  ACTION_SCHEMAS_DIR
+} from "./chunk-XS7EX55U.js";
+import "./chunk-FD4ZDTQ6.js";
+import "./chunk-U5PWXS3J.js";
+import "./chunk-VI7ZANB3.js";
+import "./chunk-VQIUTCK2.js";
+
+// src/vite-plugin/server-boundary.ts
+import { existsSync, statSync } from "fs";
+import { dirname, isAbsolute, join, relative, resolve } from "path";
+import { fileURLToPath } from "url";
+var THEO_SERVER_SPECIFIER = "theokit/server";
+var SOURCE_EXTENSIONS = [".ts", ".tsx", ".js", ".jsx", ".mts", ".mjs", ".cts", ".cjs"];
+var ServerOnlyImportError = class extends Error {
+  name = "ServerOnlyImportError";
+  /** The server-only module, as named in the message. */
+  module;
+  /** The importing file, as named in the message. */
+  importer;
+  constructor(opts) {
+    const wroteSomethingElse = opts.specifier !== void 0 && opts.specifier !== opts.module;
+    const message = [
+      `Server-only import in the client bundle: ${opts.module} cannot be imported from client code.`,
+      ``,
+      `  Imported: ${opts.module}`,
+      ...wroteSomethingElse ? [`  Written:  ${String(opts.specifier)}`] : [],
+      `  From:     ${opts.importer}`,
+      ``,
+      `That module runs on the server. It reads the file system, opens the database and holds`,
+      `your secrets, so a browser bundle containing it ships all three to every visitor.`,
+      ``,
+      `Call the server from client code instead:`,
+      ``,
+      // Both bindings are the ones the virtual modules actually export — `client` from
+      // `app-typed-client.ts` and `actions` from `actions-virtual-module.ts`. A remedy naming a
+      // symbol nobody exports reads as actionable and is not, so
+      // `tests/unit/server-boundary-rule.test.ts` asserts both against the emitters — the same
+      // discipline `tests/unit/policy-gate-remedy-is-importable.test.ts` applies to the policy gate.
+      `  import { client } from '@theo/client'    // typed from your server/routes/**`,
+      `  import { actions } from '@theo/actions'  // typed from your server/actions/**`,
+      ``,
+      `Need only the TYPES? Add \`type\` to the import \u2014 a type-only import is erased before the`,
+      `bundler ever sees it:`,
+      ``,
+      `  import type { ... } from '${opts.specifier ?? opts.module}'`,
+      ``,
+      `And if this file is itself server code, move it under your server directory, so the client`,
+      `graph has no way to reach it.`
+    ].join("\n");
+    super(message);
+    this.module = opts.module;
+    this.importer = opts.importer;
+  }
+};
+function isUnder(child, parent) {
+  const rel = relative(parent, child);
+  return rel !== "" && !rel.startsWith("..") && !isAbsolute(rel);
+}
+function nameSourceFile(target) {
+  if (existsSync(target) && statSync(target).isFile()) return target;
+  const stem = target.replace(/\.[cm]?[jt]sx?$/, "");
+  for (const ext of SOURCE_EXTENSIONS) {
+    if (existsSync(`${stem}${ext}`)) return `${stem}${ext}`;
+  }
+  for (const ext of SOURCE_EXTENSIONS) {
+    if (existsSync(join(target, `index${ext}`))) return join(target, `index${ext}`);
+  }
+  return target;
+}
+function forHumans(path, projectRoot) {
+  return isUnder(path, projectRoot) ? relative(projectRoot, path) : path;
+}
+function frameworkServerSpecifier(target, theoServerDir) {
+  const demangled = target.replace(/[\\/]index\.[cm]?[jt]sx?(?=[\\/])/, "");
+  const subpath = relative(theoServerDir, demangled).replace(/\\/g, "/").replace(/(^|\/)index\.[cm]?[jt]sx?$/, "");
+  return subpath === "" ? THEO_SERVER_SPECIFIER : `${THEO_SERVER_SPECIFIER}/${subpath}`;
+}
+function serverOnlyImportBoundary(opts) {
+  const projectRoot = opts.projectRoot;
+  const serverDir = opts.serverDir;
+  const isomorphicSchemasDir = join(serverDir, "actions", ACTION_SCHEMAS_DIR);
+  const theoServerDir = join(resolveTheoRootDir(dirname(fileURLToPath(import.meta.url))), "server");
+  return {
+    name: "theo:server-only-import-boundary",
+    enforce: "pre",
+    resolveId(source, importer, options) {
+      if (options.ssr === true) return void 0;
+      if (importer === void 0) return void 0;
+      if (source === THEO_SERVER_SPECIFIER || source.startsWith(`${THEO_SERVER_SPECIFIER}/`)) {
+        throw new ServerOnlyImportError({
+          module: source,
+          importer: forHumans(importer, projectRoot)
+        });
+      }
+      if (source.startsWith(".") || isAbsolute(source)) {
+        const target = isAbsolute(source) ? source : resolve(dirname(importer), source);
+        if (isUnder(target, theoServerDir)) {
+          throw new ServerOnlyImportError({
+            module: frameworkServerSpecifier(target, theoServerDir),
+            importer: forHumans(importer, projectRoot)
+          });
+        }
+        if (isUnder(target, serverDir) && !isUnder(target, isomorphicSchemasDir)) {
+          throw new ServerOnlyImportError({
+            module: forHumans(nameSourceFile(target), projectRoot),
+            importer: forHumans(importer, projectRoot),
+            specifier: source
+          });
+        }
+      }
+      return void 0;
+    }
+  };
+}
+export {
+  ServerOnlyImportError,
+  serverOnlyImportBoundary
+};
+//# sourceMappingURL=server-boundary-7VZQRPPX.js.map

package/dist/server-boundary-7VZQRPPX.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/vite-plugin/server-boundary.ts"],"sourcesContent":["/* eslint-disable security/detect-non-literal-fs-filename --\n * Build-time boundary check. The only paths handed to `fs` are derived from an import specifier\n * already inside the module graph, and every one of them is on the throw path — the check has\n * already decided to fail the build by the time a file is probed. No HTTP input reaches here.\n */\nimport { existsSync, statSync } from 'node:fs'\nimport { dirname, isAbsolute, join, relative, resolve } from 'node:path'\nimport { fileURLToPath } from 'node:url'\n\nimport type { Plugin } from 'vite'\n\nimport { ACTION_SCHEMAS_DIR } from '../server/internal-api.js'\n\nimport { resolveTheoRootDir } from './resolve-theo-root.js'\n\n/**\n * The framework's server surface, as one specifier.\n *\n * Every server entry point in `packages/theo/package.json` is `./server` or a `./server/<name>`\n * subpath, so this prefix covers the whole surface without listing it — and a subpath added to the\n * `exports` map tomorrow is covered on the day it ships rather than the day someone remembers this\n * file. `tests/unit/server-boundary-rule.test.ts` reads that map and\n * asserts the correspondence in both directions, so the prefix cannot quietly start over- or\n * under-matching.\n */\nconst THEO_SERVER_SPECIFIER = 'theokit/server'\n\n/** Extensions the boundary probes when naming the file behind a specifier. */\nconst SOURCE_EXTENSIONS = ['.ts', '.tsx', '.js', '.jsx', '.mts', '.mjs', '.cts', '.cjs'] as const\n\ninterface ServerOnlyImportErrorOptions {\n  /** The server-only module, named the way the reader should recognise it. */\n  module: string\n  /** The file whose import statement crossed the boundary. */\n  importer: string\n  /** The specifier exactly as written, when it differs from `module`. */\n  specifier?: string\n}\n\n/**\n * Thrown by the server-only import boundary when a module that runs on the server is pulled into\n * the CLIENT module graph.\n *\n * The failure it replaces was not the absence of one. `theokit build` already failed on this\n * mistake — with `\"resolve\" is not exported by \"__vite-browser-external\"`, pointing at a framework\n * chunk, after thirty lines of externalisation warnings (usetheokit/theokit#373). That names the\n * bundler's difficulty, not the author's. Worse, it is an accident: it happens because Node\n * builtins do not exist in a browser, so a server module that imported none of them would have\n * bundled cleanly and shipped.\n *\n * This error makes the boundary a rule instead of a side effect, and names the two things the\n * author needs — the module, and the file that imported it — the way `RouterConventionError` and\n * `MissingRoutePolicyError` already do for a bad route filename and an undeclared policy.\n */\nexport class ServerOnlyImportError extends Error {\n  override readonly name = 'ServerOnlyImportError'\n  /** The server-only module, as named in the message. */\n  readonly module: string\n  /** The importing file, as named in the message. */\n  readonly importer: string\n\n  constructor(opts: ServerOnlyImportErrorOptions) {\n    const wroteSomethingElse = opts.specifier !== undefined && opts.specifier !== opts.module\n    const message = [\n      `Server-only import in the client bundle: ${opts.module} cannot be imported from client code.`,\n      ``,\n      `  Imported: ${opts.module}`,\n      ...(wroteSomethingElse ? [`  Written:  ${String(opts.specifier)}`] : []),\n      `  From:     ${opts.importer}`,\n      ``,\n      `That module runs on the server. It reads the file system, opens the database and holds`,\n      `your secrets, so a browser bundle containing it ships all three to every visitor.`,\n      ``,\n      `Call the server from client code instead:`,\n      ``,\n      // Both bindings are the ones the virtual modules actually export — `client` from\n      // `app-typed-client.ts` and `actions` from `actions-virtual-module.ts`. A remedy naming a\n      // symbol nobody exports reads as actionable and is not, so\n      // `tests/unit/server-boundary-rule.test.ts` asserts both against the emitters — the same\n      // discipline `tests/unit/policy-gate-remedy-is-importable.test.ts` applies to the policy gate.\n      `  import { client } from '@theo/client'    // typed from your server/routes/**`,\n      `  import { actions } from '@theo/actions'  // typed from your server/actions/**`,\n      ``,\n      `Need only the TYPES? Add \\`type\\` to the import — a type-only import is erased before the`,\n      `bundler ever sees it:`,\n      ``,\n      `  import type { ... } from '${opts.specifier ?? opts.module}'`,\n      ``,\n      `And if this file is itself server code, move it under your server directory, so the client`,\n      `graph has no way to reach it.`,\n    ].join('\\n')\n    super(message)\n    this.module = opts.module\n    this.importer = opts.importer\n  }\n}\n\n/** True when `child` is inside `parent` (and is not `parent` itself). */\nfunction isUnder(child: string, parent: string): boolean {\n  const rel = relative(parent, child)\n  return rel !== '' && !rel.startsWith('..') && !isAbsolute(rel)\n}\n\n/**\n * Name the file a specifier points at.\n *\n * A TypeScript ESM import writes `./health.js` for a file called `health.ts`, and an author told\n * to look at `server/routes/health.js` will open a file that does not exist. Runs only when the\n * boundary has already decided to throw, so the probing costs nothing on a passing build; falls\n * back to the unresolved path rather than inventing one.\n */\nfunction nameSourceFile(target: string): string {\n  if (existsSync(target) && statSync(target).isFile()) return target\n  const stem = target.replace(/\\.[cm]?[jt]sx?$/, '')\n  for (const ext of SOURCE_EXTENSIONS) {\n    if (existsSync(`${stem}${ext}`)) return `${stem}${ext}`\n  }\n  for (const ext of SOURCE_EXTENSIONS) {\n    if (existsSync(join(target, `index${ext}`))) return join(target, `index${ext}`)\n  }\n  return target\n}\n\n/** Render a path relative to the project root, keeping it absolute when it lives outside. */\nfunction forHumans(path: string, projectRoot: string): string {\n  return isUnder(path, projectRoot) ? relative(projectRoot, path) : path\n}\n\n/**\n * Name a file inside the framework's own server tree the way its `package.json` publishes it.\n *\n * Two normalisations, both undoing something a bundler did to a specifier the author never wrote:\n *\n * - **The alias mangle.** `config-hook.ts` aliases the STRING `theokit/server` to a FILE, and a\n *   Vite string alias replaces by prefix, so `theokit/server/define` reaches this plugin as\n *   `…/server/index.ts/define`. That mid-path `/index.ts/` is the mangle — the same shape that\n *   surfaced as `ENOTDIR` in usetheokit/theokit#373 — and stripping it recovers `define`.\n * - **The barrel file.** `./server` and `./server/define` publish as `…/index.js` in `dist` and\n *   `…/index.ts` in source; a trailing barrel segment is not part of the specifier.\n *\n * The result is the string a reader can grep for in `packages/theo/package.json`.\n */\nfunction frameworkServerSpecifier(target: string, theoServerDir: string): string {\n  const demangled = target.replace(/[\\\\/]index\\.[cm]?[jt]sx?(?=[\\\\/])/, '')\n  const subpath = relative(theoServerDir, demangled)\n    .replace(/\\\\/g, '/')\n    .replace(/(^|\\/)index\\.[cm]?[jt]sx?$/, '')\n  return subpath === '' ? THEO_SERVER_SPECIFIER : `${THEO_SERVER_SPECIFIER}/${subpath}`\n}\n\nexport interface ServerBoundaryOptions {\n  /** Absolute project root — paths in the message are shown relative to it. */\n  projectRoot: string\n  /** Absolute backend root (config `serverDir`, default `<projectRoot>/server`). */\n  serverDir: string\n}\n\n/**\n * Refuse a server-only module in the client module graph, by name.\n *\n * ## Where the check lives, and why here\n *\n * In `resolveId`, at `enforce: 'pre'`. Three reasons, in the order they mattered:\n *\n * 1. **It is the only hook that sees the triple the message needs** — specifier, importer, and\n *    whether this is the client graph or the SSR one. A `package.json` `exports` map has no\n *    client/server condition a bundler honours for a build, and a standalone gate over `dist/`\n *    would have to rebuild the module graph Rollup just built.\n * 2. **`pre` runs ahead of the alias cascade.** `config-hook.ts` aliases `theokit/server` to a\n *    FILE, and a Vite string alias matches by prefix, so `theokit/server/define` used to resolve\n *    to `…/server/index.js/define` and fail with `ENOTDIR` — the second half of #373. Catching the\n *    specifier before the alias replaces it turns that into the same named refusal as the bare\n *    import. (The alias bug itself is untouched here — it is usetheokit/theokit#377, and it still\n *    breaks `theokit/client/core`, a published entry point that no boundary should refuse.)\n * 3. **It is on the path a consumer runs.** `theokit build` → `runAdapterBuild` → `nodeAdapter` →\n *    `viteBuild({ plugins: await ctx.makeVitePlugins(…) })` → `theoPluginAsync`, which returns this\n *    plugin. Nothing has to opt in, and `tests/integration/server-only-import-boundary.test.ts`\n *    exercises that chain rather than calling the hook.\n *\n * ## What counts as server-only\n *\n * Two rules, and one exception that is not a special case so much as the framework's own\n * declaration:\n *\n * - Anything under the published `theokit/server` surface (see {@link THEO_SERVER_SPECIFIER}).\n * - Anything under the project's own `serverDir`, EXCEPT `actions/<ACTION_SCHEMAS_DIR>/**`, which\n *   the `@theo/actions` facade deliberately imports into the client bundle. The exception reads\n *   the same constant the action scanner uses, so renaming the convention cannot turn a shipped\n *   feature into a build error on one side only.\n *\n * The second rule exists so the message names the page the author wrote. Without it a client page\n * importing `server/routes/health.ts` still fails — health.ts imports `theokit/server/define` — but\n * the importer named is `health.ts`, one hop away from the mistake.\n *\n * ## What it deliberately does not do\n *\n * It does not walk the import chain to report how a deeply nested server module was reached, and it\n * does not fire on the SSR graph, in `theokit build --target` SSR passes or under `ssrLoadModule`,\n * where importing server code is the entire point.\n */\nexport function serverOnlyImportBoundary(opts: ServerBoundaryOptions): Plugin {\n  const projectRoot = opts.projectRoot\n  const serverDir = opts.serverDir\n  const isomorphicSchemasDir = join(serverDir, 'actions', ACTION_SCHEMAS_DIR)\n  // The framework's own server tree on disk — `src/server` in this workspace, `dist/server` in an\n  // installed copy. Resolved through the same helper `theoPlugin()` uses for its aliases, so the\n  // boundary and the aliases can never point at different trees.\n  const theoServerDir = join(resolveTheoRootDir(dirname(fileURLToPath(import.meta.url))), 'server')\n\n  return {\n    name: 'theo:server-only-import-boundary',\n    enforce: 'pre',\n\n    resolveId(source, importer, options) {\n      // The SSR graph is allowed — and required — to import server code.\n      if (options.ssr === true) return undefined\n      // An entry point has no importer, so the message could not name one. A `theokit/server`\n      // entry is a deliberate act in someone's Vite config, not the accident this catches.\n      if (importer === undefined) return undefined\n\n      // The specifier as the author wrote it. Reached only when no alias rewrote it first —\n      // Vite's own alias plugin runs ahead of every `enforce: 'pre'` plugin, and `config-hook.ts`\n      // installs an alias for exactly this prefix. Kept anyway so the boundary holds for a\n      // consumer whose Vite config does not carry that alias.\n      if (source === THEO_SERVER_SPECIFIER || source.startsWith(`${THEO_SERVER_SPECIFIER}/`)) {\n        throw new ServerOnlyImportError({\n          module: source,\n          importer: forHumans(importer, projectRoot),\n        })\n      }\n\n      // A bare specifier can never be a file, so only relative and absolute sources are resolved —\n      // which keeps the common case to two string comparisons.\n      if (source.startsWith('.') || isAbsolute(source)) {\n        const target = isAbsolute(source) ? source : resolve(dirname(importer), source)\n\n        // The framework's server surface, recognised by PATH because that is the form it arrives\n        // in after the alias. Matching the tree rather than the specifier also catches a deep\n        // reach into `theokit`'s internals that no `exports` subpath names.\n        if (isUnder(target, theoServerDir)) {\n          throw new ServerOnlyImportError({\n            module: frameworkServerSpecifier(target, theoServerDir),\n            importer: forHumans(importer, projectRoot),\n          })\n        }\n\n        if (isUnder(target, serverDir) && !isUnder(target, isomorphicSchemasDir)) {\n          throw new ServerOnlyImportError({\n            module: forHumans(nameSourceFile(target), projectRoot),\n            importer: forHumans(importer, projectRoot),\n            specifier: source,\n          })\n        }\n      }\n\n      return undefined\n    },\n  }\n}\n"],"mappings":"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","names":[]}

package/dist/{services-typed-client-PSAGRPFF.js → services-typed-client-XGT5SUUN.js}

@@ -2,7 +2,7 @@
 import "tsx/esm";
 import {
   generateTypedClient
-} from "./chunk-7VPQHEAJ.js";
+} from "./chunk-ZNZISJDZ.js";
 
 // src/vite-plugin/services-typed-client.ts
 import { resolve } from "path";
@@ -44,4 +44,4 @@ function servicesTypedClientPlugin(opts) {
 export {
   servicesTypedClientPlugin
 };
-//# sourceMappingURL=services-typed-client-PSAGRPFF.js.map
+//# sourceMappingURL=services-typed-client-XGT5SUUN.js.map