@cloudflare/vitest-pool-workers 0.2.4 → 0.2.6

package/dist/config/d1.d.ts

@@ -0,0 +1,7 @@
+import type { D1Migration } from "../shared/d1";
+/**
+ * Reads all migrations in `migrationsPath`, ordered by migration number.
+ * Each migration will have its contents split into an array of SQL queries.
+ */
+export declare function readD1Migrations(migrationsPath: string): Promise<D1Migration[]>;
+export type { D1Migration };

package/dist/config/index.cjs

@@ -0,0 +1,130 @@
+"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)
+    __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 __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/config/index.ts
+var config_exports = {};
+__export(config_exports, {
+  defineWorkersConfig: () => defineWorkersConfig,
+  defineWorkersProject: () => defineWorkersProject,
+  readD1Migrations: () => readD1Migrations
+});
+module.exports = __toCommonJS(config_exports);
+var import_node_assert = __toESM(require("node:assert"));
+var import_node_worker_threads = require("node:worker_threads");
+
+// src/config/d1.ts
+var import_node_fs = __toESM(require("node:fs"));
+var import_node_path = __toESM(require("node:path"));
+async function readD1Migrations(migrationsPath) {
+  const { unstable_splitSqlQuery } = await import("wrangler");
+  const names = import_node_fs.default.readdirSync(migrationsPath).filter((name) => name.endsWith(".sql"));
+  names.sort((a, b) => {
+    const aNumber = parseInt(a.split("_")[0]);
+    const bNumber = parseInt(b.split("_")[0]);
+    return aNumber - bNumber;
+  });
+  return names.map((name) => {
+    const migrationPath = import_node_path.default.join(migrationsPath, name);
+    const migration = import_node_fs.default.readFileSync(migrationPath, "utf8");
+    const queries = unstable_splitSqlQuery(migration);
+    return { name, queries };
+  });
+}
+
+// src/config/index.ts
+var channel;
+globalThis.structuredClone ??= function(value, options) {
+  channel ??= new import_node_worker_threads.MessageChannel();
+  channel.port1.unref();
+  channel.port2.unref();
+  channel.port1.postMessage(value, options?.transfer);
+  const message = (0, import_node_worker_threads.receiveMessageOnPort)(channel.port2);
+  (0, import_node_assert.default)(message !== void 0);
+  return message.message;
+};
+function mapAnyConfigExport(f, config) {
+  if (typeof config === "function") {
+    return (env) => {
+      const t = config(env);
+      if (t instanceof Promise) {
+        return t.then(f);
+      } else {
+        return f(t);
+      }
+    };
+  } else if (config instanceof Promise) {
+    return config.then(f);
+  } else {
+    return f(config);
+  }
+}
+function ensureArrayIncludes(array, items) {
+  for (const item of items)
+    if (!array.includes(item))
+      array.push(item);
+}
+var requiredConditions = ["workerd", "worker", "browser"];
+var requiredMainFields = ["browser", "module", "jsnext:main", "jsnext"];
+var configPlugin = {
+  name: "@cloudflare/vitest-pool-workers:config",
+  // Run after `vitest:project` plugin:
+  // https://github.com/vitest-dev/vitest/blob/8014614475afa880f4e583b166bb91dea5415cc6/packages/vitest/src/node/plugins/workspace.ts#L26
+  config(config) {
+    config.resolve ??= {};
+    config.resolve.conditions ??= [];
+    config.resolve.mainFields ??= [];
+    config.ssr ??= {};
+    config.test ??= {};
+    const nodeIndex = config.resolve.conditions.indexOf("node");
+    if (nodeIndex !== -1)
+      config.resolve.conditions.splice(nodeIndex, 1);
+    ensureArrayIncludes(config.resolve.conditions, requiredConditions);
+    ensureArrayIncludes(config.resolve.mainFields, requiredMainFields);
+    config.ssr.target = "webworker";
+    config.test.pool ??= "@cloudflare/vitest-pool-workers";
+  }
+};
+function ensureWorkersConfig(config) {
+  config.plugins ??= [];
+  config.plugins.push(configPlugin);
+  return config;
+}
+function defineWorkersConfig(config) {
+  return mapAnyConfigExport(ensureWorkersConfig, config);
+}
+function defineWorkersProject(config) {
+  return mapAnyConfigExport(ensureWorkersConfig, config);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  defineWorkersConfig,
+  defineWorkersProject,
+  readD1Migrations
+});
+//# sourceMappingURL=index.cjs.map

package/dist/config/index.cjs.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../src/config/index.ts", "../../src/config/d1.ts"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,yBAAmB;AACnB,iCAAqD;;;ACDrD,qBAAe;AACf,uBAAiB;AAOjB,eAAsB,iBACrB,gBACyB;AACzB,QAAM,EAAE,uBAAuB,IAAI,MAAM,OAAO,UAAU;AAC1D,QAAM,QAAQ,eAAAA,QACZ,YAAY,cAAc,EAC1B,OAAO,CAAC,SAAS,KAAK,SAAS,MAAM,CAAC;AACxC,QAAM,KAAK,CAAC,GAAG,MAAM;AACpB,UAAM,UAAU,SAAS,EAAE,MAAM,GAAG,EAAE,CAAC,CAAC;AACxC,UAAM,UAAU,SAAS,EAAE,MAAM,GAAG,EAAE,CAAC,CAAC;AACxC,WAAO,UAAU;AAAA,EAClB,CAAC;AACD,SAAO,MAAM,IAAI,CAAC,SAAS;AAC1B,UAAM,gBAAgB,iBAAAC,QAAK,KAAK,gBAAgB,IAAI;AACpD,UAAM,YAAY,eAAAD,QAAG,aAAa,eAAe,MAAM;AACvD,UAAM,UAAU,uBAAuB,SAAS;AAChD,WAAO,EAAE,MAAM,QAAQ;AAAA,EACxB,CAAC;AACF;;;ADhBA,IAAI;AACJ,WAAW,oBAAoB,SAAU,OAAO,SAAS;AAExD,cAAY,IAAI,0CAAe;AAC/B,UAAQ,MAAM,MAAM;AACpB,UAAQ,MAAM,MAAM;AACpB,UAAQ,MAAM,YAAY,OAAO,SAAS,QAAQ;AAClD,QAAM,cAAU,iDAAqB,QAAQ,KAAK;AAClD,yBAAAE,SAAO,YAAY,MAAS;AAC5B,SAAO,QAAQ;AAChB;AAMA,SAAS,mBACR,GACA,QACqB;AACrB,MAAI,OAAO,WAAW,YAAY;AACjC,WAAO,CAAC,QAAQ;AACf,YAAM,IAAI,OAAO,GAAG;AACpB,UAAI,aAAa,SAAS;AACzB,eAAO,EAAE,KAAK,CAAC;AAAA,MAChB,OAAO;AACN,eAAO,EAAE,CAAC;AAAA,MACX;AAAA,IACD;AAAA,EACD,WAAW,kBAAkB,SAAS;AACrC,WAAO,OAAO,KAAK,CAAC;AAAA,EACrB,OAAO;AACN,WAAO,EAAE,MAAM;AAAA,EAChB;AACD;AAsBA,SAAS,oBAAuB,OAAY,OAAY;AACvD,aAAW,QAAQ;AAAO,QAAI,CAAC,MAAM,SAAS,IAAI;AAAG,YAAM,KAAK,IAAI;AACrE;AAEA,IAAM,qBAAqB,CAAC,WAAW,UAAU,SAAS;AAC1D,IAAM,qBAAqB,CAAC,WAAW,UAAU,eAAe,QAAQ;AAExE,IAAM,eAA6B;AAAA,EAClC,MAAM;AAAA;AAAA;AAAA,EAGN,OAAO,QAAQ;AACd,WAAO,YAAY,CAAC;AACpB,WAAO,QAAQ,eAAe,CAAC;AAC/B,WAAO,QAAQ,eAAe,CAAC;AAC/B,WAAO,QAAQ,CAAC;AAChB,WAAO,SAAS,CAAC;AAIjB,UAAM,YAAY,OAAO,QAAQ,WAAW,QAAQ,MAAM;AAC1D,QAAI,cAAc;AAAI,aAAO,QAAQ,WAAW,OAAO,WAAW,CAAC;AAInE,wBAAoB,OAAO,QAAQ,YAAY,kBAAkB;AAIjE,wBAAoB,OAAO,QAAQ,YAAY,kBAAkB;AAIjE,WAAO,IAAI,SAAS;AAIpB,WAAO,KAAK,SAAS;AAAA,EACtB;AACD;AAEA,SAAS,oBAA0C,QAAc;AAChE,SAAO,YAAY,CAAC;AACpB,SAAO,QAAQ,KAAK,YAAY;AAChC,SAAO;AACR;AAEO,SAAS,oBACf,QAC2C;AAC3C,SAAO,mBAAmB,qBAAqB,MAAM;AACtD;AAEO,SAAS,qBACf,QAC8C;AAC9C,SAAO,mBAAmB,qBAAqB,MAAM;AACtD;",
+  "names": ["fs", "path", "assert"]
+}

package/dist/config/index.d.ts

@@ -0,0 +1,21 @@
+import type { WorkersPoolOptions } from "../pool/config";
+import type { Awaitable, inject } from "vitest";
+import type { ConfigEnv, UserConfig, UserWorkspaceConfig } from "vitest/config";
+export type AnyConfigExport<T extends UserConfig> = T | Promise<T> | ((env: ConfigEnv) => T | Promise<T>);
+export interface WorkerPoolOptionsContext {
+    inject: typeof inject;
+}
+export type WorkersUserConfig<T extends UserConfig> = T & {
+    test?: {
+        pool?: "@cloudflare/vitest-pool-workers";
+        poolMatchGlobs?: never;
+        poolOptions?: {
+            workers?: WorkersPoolOptions | ((ctx: WorkerPoolOptionsContext) => Awaitable<WorkersPoolOptions>);
+        };
+    };
+};
+export type WorkersUserConfigExport = WorkersUserConfig<UserConfig>;
+export type WorkersProjectConfigExport = WorkersUserConfig<UserWorkspaceConfig>;
+export declare function defineWorkersConfig(config: AnyConfigExport<WorkersUserConfigExport>): AnyConfigExport<WorkersUserConfigExport>;
+export declare function defineWorkersProject(config: AnyConfigExport<WorkersProjectConfigExport>): AnyConfigExport<WorkersProjectConfigExport>;
+export * from "./d1";

package/dist/pool/config.d.ts

@@ -0,0 +1,82 @@
+import { z } from "zod";
+import type { ModuleRule, WorkerOptions } from "miniflare";
+import type { WorkspaceProject } from "vitest/node";
+export declare const OPTIONS_PATH: string;
+declare const WorkersPoolOptionsSchema: z.ZodObject<{
+    /**
+     * Entrypoint to Worker run in the same isolate/context as tests. This is
+     * required to use `import { SELF } from "cloudflare:test"`, or Durable
+     * Objects without an explicit `scriptName`. Note this goes through Vite
+     * transforms and can be a TypeScript file. Note also
+     * `import module from "<path-to-main>"` inside tests gives exactly the same
+     * `module` instance as is used internally for the `SELF` and Durable Object
+     * bindings.
+     */
+    main: z.ZodOptional<z.ZodString>;
+    /**
+     * Enables per-test isolated storage. If enabled, any writes to storage
+     * performed in a test will be undone at the end of the test. The test storage
+     * environment is copied from the containing suite, meaning `beforeAll()`
+     * hooks can be used to seed data. If this is disabled, all tests will share
+     * the same storage.
+     */
+    isolatedStorage: z.ZodDefault<z.ZodBoolean>;
+    /**
+     * Runs all tests in this project serially in the same worker, using the same
+     * module cache. This can significantly speed up tests if you've got lots of
+     * small test files.
+     */
+    singleWorker: z.ZodDefault<z.ZodBoolean>;
+    miniflare: z.ZodOptional<z.ZodObject<{
+        workers: z.ZodOptional<z.ZodArray<z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>, "many">>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        workers: z.ZodOptional<z.ZodArray<z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>, "many">>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        workers: z.ZodOptional<z.ZodArray<z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>, "many">>;
+    }, z.ZodTypeAny, "passthrough">>>;
+    wrangler: z.ZodOptional<z.ZodObject<{
+        configPath: z.ZodOptional<z.ZodString>;
+        environment: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        configPath?: string | undefined;
+        environment?: string | undefined;
+    }, {
+        configPath?: string | undefined;
+        environment?: string | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    isolatedStorage: boolean;
+    singleWorker: boolean;
+    main?: string | undefined;
+    miniflare?: z.objectOutputType<{
+        workers: z.ZodOptional<z.ZodArray<z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>, "many">>;
+    }, z.ZodTypeAny, "passthrough"> | undefined;
+    wrangler?: {
+        configPath?: string | undefined;
+        environment?: string | undefined;
+    } | undefined;
+}, {
+    main?: string | undefined;
+    isolatedStorage?: boolean | undefined;
+    singleWorker?: boolean | undefined;
+    miniflare?: z.objectInputType<{
+        workers: z.ZodOptional<z.ZodArray<z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>, "many">>;
+    }, z.ZodTypeAny, "passthrough"> | undefined;
+    wrangler?: {
+        configPath?: string | undefined;
+        environment?: string | undefined;
+    } | undefined;
+}>;
+export type SourcelessWorkerOptions = Omit<WorkerOptions, "script" | "scriptPath" | "modules" | "modulesRoot"> & {
+    modulesRules?: ModuleRule[];
+};
+export type WorkersPoolOptions = z.input<typeof WorkersPoolOptionsSchema> & {
+    miniflare?: SourcelessWorkerOptions & {
+        workers?: WorkerOptions[];
+    };
+};
+export type WorkersPoolOptionsWithDefines = WorkersPoolOptions & {
+    defines?: Record<string, string>;
+};
+export declare function parseProjectOptions(project: WorkspaceProject): Promise<WorkersPoolOptionsWithDefines>;
+export {};

package/dist/pool/helpers.d.ts

@@ -0,0 +1,5 @@
+import type { WorkspaceProject } from "vitest/node";
+export declare const WORKER_NAME_PREFIX = "vitest-pool-workers-";
+export declare function isFileNotFoundError(e: unknown): boolean;
+export declare function getProjectPath(project: WorkspaceProject): string | number;
+export declare function getRelativeProjectPath(project: WorkspaceProject): string | number;