@wasp.sh/wasp-cli-darwin-x64-unknown 0.25.0 → 0.26.0

package/data/Generator/templates/sdk/wasp/client/router/types.ts

@@ -1,98 +0,0 @@
-// PRIVATE API
-export type RouteDefinitionsToRoutes<Routes extends RoutesDefinition> =
-  RouteDefinitionsToRoutesObj<Routes>[keyof RouteDefinitionsToRoutesObj<Routes>]
-
-// PRIVATE API
-export type OptionalRouteOptions = {
-  search?: Search
-  hash?: string
-}
-
-// PRIVATE API
-export type ParamValue = string | number
-// PRIVATE API
-export type Params = { [name: string]: ParamValue }
-// PRIVATE API
-export type Search =
-  | string[][]
-  | Record<string, string>
-  | string
-  | URLSearchParams
-
-type RouteDefinitionsToRoutesObj<Routes extends RoutesDefinition> = {
-  [K in keyof Routes]: {
-    to: ExpandRouteOnOptionalStaticSegments<Routes[K]['to']>
-  } & ParamsFromBuildFn<Routes[K]['build']>
-}
-
-type RoutesDefinition = {
-  [name: string]: {
-    to: string
-    build: BuildFn
-  }
-}
-
-type BuildFn = (params: never) => string
-
-type ParamsFromBuildFn<BF extends BuildFn> = Parameters<BF>[0] extends {
-  params: infer Params
-}
-  ? { params: Params }
-  : { params?: never }
-
-// PRIVATE API (sdk)
-/**
- * Optional static segments handling: expands routes with optional segments
- * into multiple routes, one for each possible combination of optional segments.
- *
- * For example: /users/tasks?/:id? will be expanded into two routes:
- * - /users/:id?
- * - /users/tasks/:id?
- */
-export type ExpandRouteOnOptionalStaticSegments<Route extends string> = JoinPath<
-  ExpandOptionalSegments<ParseSegments<SplitPath<NonEmptyString<Route>>>>
->;
-
-type ParseSegments<T> = T extends [infer Head, ...infer Tail]
-  ? [_ParseSegment<Head>, ...ParseSegments<Tail>]
-  : T;
-
-type _ParseSegment<T> = T extends `:${infer P}`
-  ? // Param segment
-    { segment: T }
-  : T extends `${infer S}?`
-    ? // Optional segment
-      { optionalSegment: S }
-    : // Regular segment
-      { segment: T };
-
-type Segment = { segment: string };
-type OptionalSegment = { optionalSegment: string };
-
-type Elem = Segment | OptionalSegment;
-
-type ExpandOptionalSegments<T extends Elem[]> = T extends []
-  ? []
-  : T extends [infer First extends Elem, ...infer Rest extends Elem[]]
-    ? First extends Segment
-      ? [First["segment"], ...ExpandOptionalSegments<Rest>]
-      : First extends OptionalSegment
-        ? [First["optionalSegment"], ...ExpandOptionalSegments<Rest>] | ExpandOptionalSegments<Rest>
-        : []
-    : [];
-
-type SplitPath<S extends string> = S extends "/"
-  ? [""]
-  : S extends `${infer T}/${infer U}`
-    ? [T, ...SplitPath<U>]
-    : [S];
-
-type JoinPath<T extends string[]> = T extends [infer Only extends string]
-  ? Only extends ""
-    ? "/"
-    : Only
-  : T extends [infer First extends string, ...infer Rest extends string[]]
-    ? `${First}/${JoinPath<Rest>}`
-    : never;
-
-type NonEmptyString<S extends string> = S extends "" ? never : S;

package/data/Generator/templates/sdk/wasp/client/vite/plugins/detectServerImports.ts

@@ -1,50 +0,0 @@
-{{={= =}=}}
-import { type Plugin } from 'vite'
-import path from 'path'
-
-export function detectServerImports(): Plugin {
-  let parsePathToUserCode!: ParsePathToUserCodeFn
-  return {
-    name: 'wasp:detect-server-imports',
-    enforce: 'pre',
-    configResolved(config) {
-      parsePathToUserCode = createPathToUserCodeParser(config.root)
-    },
-    resolveId(source, importer) {
-      if (!importer) {
-        return
-      }
-
-      const pathToUserCode = parsePathToUserCode(importer)
-      if (!pathToUserCode) {
-        return
-      }
-
-      if (isServerImport(source)) {
-        throw new Error(
-          `Server code cannot be imported in the client code. Import from "${source}" in "${pathToUserCode}" is not allowed.`
-        )
-      }
-    },
-  }
-}
-
-function isServerImport(moduleName: string): boolean {
-  return moduleName.startsWith('wasp/server')
-}
-
-type RelativePathToUserCode = string & { _brand: 'relativePathToUserCode' }
-
-type ParsePathToUserCodeFn = (importerPath: string) => RelativePathToUserCode | null;
-
-function createPathToUserCodeParser(waspProjectDirPath: string): ParsePathToUserCodeFn {
-  return (importerPath: string): RelativePathToUserCode | null => {
-    const importerPathRelativeToWaspProjectDir = path.relative(
-      waspProjectDirPath,
-      importerPath
-    )
-    return importerPathRelativeToWaspProjectDir.startsWith('{= srcDirInWaspProjectDir =}')
-      ? (importerPathRelativeToWaspProjectDir as RelativePathToUserCode)
-      : null
-  }
-}

package/data/Generator/templates/sdk/wasp/client/vite/plugins/envFile.ts

@@ -1,112 +0,0 @@
-{{={= =}=}}
-import { type Plugin, type UserConfig } from 'vite'
-import { resolve } from 'node:path'
-import { readFile, access, constants } from 'node:fs/promises'
-import { parse as parseDotenv } from 'dotenv'
-import { expand, type DotenvPopulateInput } from 'dotenv-expand'
-
-const envFileName = '{= clientEnvFileName =}'
-
-export function envFile(): Plugin {
-  let envFilePath!: string
-  return {
-    name: 'wasp:env-file',
-    enforce: 'pre',
-    async config(config, env) {
-      const rootDir = config.root || process.cwd()
-      const envVars = await loadEnvVars({
-        rootDir,
-        // We are sure that `envPrefix` is defined because
-        // we defined it in an earlier plugin.
-        envPrefix: config.envPrefix!,
-        // We load the env file variables only in development,
-        // when building for production, users are expected to
-        // provide the environment variables inline.
-        loadDotEnvFile: env.command === 'serve',
-      })
-      envFilePath = resolve(rootDir, envFileName)
-
-      const prefixedVars = Object.entries(envVars)
-        .reduce((acc, [key, value]) => {
-          acc[`import.meta.env.${key}`] = JSON.stringify(value)
-          return acc
-        }, {} as Record<string, string>)
-
-      return {
-        // Disable Vite's default .env loading.
-        envDir: false,
-        define: prefixedVars,
-      }
-    },
-    configureServer(server) {
-      const reloadServerOnEnvFileEvent = (path: string) => {
-        if (path === envFilePath) {
-          server.restart()
-        }
-      }
-
-      server.watcher.on('add', reloadServerOnEnvFileEvent)
-      server.watcher.on('change', reloadServerOnEnvFileEvent)
-      server.watcher.on('unlink', reloadServerOnEnvFileEvent)
-    },
-    async buildStart() {
-      this.addWatchFile(envFilePath)
-    },
-  }
-}
-
-// Based on: https://github.com/vitejs/vite/blob/8bb32036792a6f522f5c947112f3d688add755a0/packages/vite/src/node/env.ts
-export async function loadEnvVars({
-  rootDir,
-  envPrefix,
-  loadDotEnvFile,
-}: {
-  rootDir: string
-  envPrefix: NonNullable<UserConfig['envPrefix']>
-  loadDotEnvFile: boolean
-}): Promise<Record<string, string>> {
-  const envPrefixNormalized = Array.isArray(envPrefix) ? envPrefix : [envPrefix]
-  const env: Record<string, string> = {}
-
-  if (loadDotEnvFile) {
-    const envFilePath = resolve(rootDir, envFileName)
-    const parsed = await parseEnvFile(envFilePath)
-
-    // Let environment variables use each other. Make a copy of `process.env` so that `dotenv-expand`
-    // doesn't re-assign the expanded values to the global `process.env`.
-    const processEnv = { ...process.env } as DotenvPopulateInput
-    expand({ parsed, processEnv })
-
-    // Only keys that start with prefix are exposed to client.
-    for (const [key, value] of Object.entries(parsed)) {
-      if (envPrefixNormalized.some(prefix => key.startsWith(prefix))) {
-        env[key] = value
-      }
-    }
-  }
-
-  // Make sure that inline env variables are prioritized over env file variables.
-  // Follows the logic Vite uses for env variables.
-  for (const key in process.env) {
-    if (envPrefixNormalized.some(prefix => key.startsWith(prefix))) {
-      env[key] = process.env[key] as string
-    }
-  }
-
-  return env
-}
-
-async function parseEnvFile(envFilePath: string): Promise<Record<string, string>> {
-  try {
-    await access(envFilePath, constants.R_OK)
-  } catch {
-    return {}
-  }
-
-  try {
-    return parseDotenv(await readFile(envFilePath, 'utf-8'))
-  } catch (error) {
-    console.error(`Error parsing ${envFileName}:`, error)
-    throw error
-  }
-}

package/data/Generator/templates/sdk/wasp/client/vite/plugins/typescriptCheck.ts

@@ -1,36 +0,0 @@
-import { type Plugin } from 'vite'
-import { spawn } from 'node:child_process'
-
-interface TypeScriptCheckOptions {
-  srcTsConfigPath: string
-}
-
-export function typescriptCheck(options: TypeScriptCheckOptions): Plugin {
-  return {
-    name: 'wasp:typescript-check',
-    apply: 'build',
-    async buildStart() {
-      await runTsc(options.srcTsConfigPath)
-    },
-  }
-}
-
-function runTsc(srcTsConfigPath: string): Promise<void> {
-  return new Promise((resolve, reject) => {
-    const child = spawn(
-      'tsc',
-      ['--project', srcTsConfigPath, '--noEmit'],
-      {
-        stdio: 'inherit',
-        shell: process.platform === 'win32',
-      }
-    )
-
-    child.once('error', reject)
-    child.once('close', (code) =>
-      code === 0
-        ? resolve()
-        : reject(new Error(`TypeScript check failed (exit ${code})`))
-    )
-  })
-}

package/data/Generator/templates/sdk/wasp/client/vite/plugins/validateEnv.ts

@@ -1,88 +0,0 @@
-{{={= =}=}}
-import path from "node:path";
-import {
-  type Plugin,
-  type ResolvedConfig,
-  createServer as createViteServer,
-  isRunnableDevEnvironment
-} from "vite";
-
-const PLUGIN_NAME = "wasp:validate-env";
-const CLIENT_ENV_SCHEMA_VALIDATION_MODULE = "{= clientEnvSchemaValidationModulePath =}"
-
-export function validateEnv(): Plugin {
-  let resolvedConfig: ResolvedConfig;
-
-  return {
-    name: PLUGIN_NAME,
-    configResolved(config) {
-      resolvedConfig = config;
-    },
-    // We validate just before any artifacts are built.
-    async buildStart() {
-      // We need to import the client env schema validation module
-      // through a Vite server, because both the user and the Wasp schema
-      // modules may depend on bundler features.
-      // Because of that we spin up a temporary Vite server.
-      //
-      // Alternatively, for `serve`, we could use the Vite server provided
-      // through the `configureServer` hook, but that would complicate
-      // the solution for negligible performance benefits.
-      const tempServer = await createViteServer({
-        root: resolvedConfig.root,
-        mode: resolvedConfig.mode,
-        // To ensure we pick up all user-defined plugins (resolution matches the main build)
-        // while avoiding recursion. This includes the `wasp` plugin.
-        configFile: false,
-        plugins: resolvedConfig.plugins
-          .filter((plugin) => plugin.name !== PLUGIN_NAME)
-
-          // Ignore `vite:`-prefixed plugins since Vite will recreate them for
-          // the temporary server anyway.
-          .filter((plugin) => !plugin.name.startsWith("vite:"))
-
-          // Vite's `configureServer`/`configurePreviewServer` hooks let plugins
-          // wire long-lived behavior into a dev or preview server: middleware,
-          // websocket handlers, file watchers, and similar background tasks.
-          //
-          // Plugins are supposed to clean these up by returning a teardown
-          // function from the hook, but some forget to, so resources they
-          // allocate end up outliving the server. This forces the original
-          // Vite process to be alive indefinitely.
-          //
-          // We don't need either hook to validate the client env schema.
-          // We only need module resolution and transforms.
-          .map((plugin) => ({
-            ...plugin,
-            configureServer: undefined,
-            configurePreviewServer: undefined,
-          })),
-
-        // Minimize side effects from spinning up a temporary dev server.
-        appType: 'custom',      // avoid HTML handling
-        server: {
-          middlewareMode: true, // do not start an actual HTTP server
-          watch: null,
-          hmr: false
-        },
-        logLevel: "silent",
-        optimizeDeps: { noDiscovery: true, include: [] },
-        clearScreen: false,
-      });
-
-      try {
-        // Vite's `ssr` means bundled for "backend JS runtime", like Node.
-        // This environment is always runnable in vite dev server.
-        if (!isRunnableDevEnvironment(tempServer.environments.ssr)) {
-          throw new Error(`Expected ssr to be a runnable dev environment`)
-        }
-        // The imported module runs env schema validation as an import
-        // side-effect and throws on failure.
-        const moduleAbsPath = path.resolve(resolvedConfig.root, CLIENT_ENV_SCHEMA_VALIDATION_MODULE);
-        await tempServer.environments.ssr.runner.import(moduleAbsPath);
-      } finally {
-        await tempServer.close();
-      }
-    },
-  };
-}

package/data/Generator/templates/sdk/wasp/client/vite/virtual-files/resolver.ts

@@ -1,35 +0,0 @@
-import * as path from "node:path"
-
-export type VirtualFiles = {
-  ids: ReadonlyMap<string, string>;
-  loaders: ReadonlyMap<string, () => Promise<string> | string>;
-};
-
-type VirtualFilesDefinition = {
-  id: string;
-  load: () => Promise<string> | string;
-};
-
-export const makeVirtualFilesResolver =
-  (files: VirtualFilesDefinition[]) =>
-  (rootPath: string): VirtualFiles => {
-    const filesWithAbsPath = files.map((d) => ({
-      ...d,
-      absPath: path.resolve(rootPath, path.basename(d.id)),
-    }));
-
-    const ids = new Map(
-      filesWithAbsPath.flatMap((d) =>
-        // We'll resolve both the relative and absolute paths for the virtual
-        // files, since Vite and other plugins may request either.
-        [
-          [d.id, d.absPath],
-          [d.absPath, d.absPath],
-        ],
-      ),
-    );
-
-    const loaders = new Map(filesWithAbsPath.map((d) => [d.absPath, d.load]));
-
-    return { ids, loaders };
-  };

package/data/Generator/templates/sdk/wasp/core/serialization/custom-register.ts

@@ -1,21 +0,0 @@
-import type { WaspInternal_CustomSerializableJSONValue_Register } from "superjson"
-
-/*
-  This is a workaround for declaring custom types through side-effects in
-  TypeScript. This way a bare import, like `import "./prisma"` will register
-  itself as a custom serialization in the type-level, like it does at the
-  runtime-level.
-
-  This declaration creates an empty interface. Implementations of custom
-  serialization types can extend this interface through augmentation
-  (https://www.typescriptlang.org/docs/handbook/declaration-merging.html#merging-interfaces).
-  We can later inspect this interface to see which custom types are registered.
-
-  This approach is copied from TanStack Router's `Register` interface
-  https://github.com/TanStack/router/blob/v1.124.1/docs/router/framework/react/guide/creating-a-router.md#router-type-safety
-*/
-declare module "superjson" {
-  interface WaspInternal_CustomSerializableJSONValue_Register {}
-}
-
-export type CustomSerializableJSONValue = WaspInternal_CustomSerializableJSONValue_Register[keyof WaspInternal_CustomSerializableJSONValue_Register]

package/data/Generator/templates/sdk/wasp/core/storage.ts

@@ -1,73 +0,0 @@
-export type DataStore = {
-  getPrefixedKey(key: string): string;
-  set(key: string, value: unknown): void;
-  get(key: string): unknown;
-  remove(key: string): void;
-  clear(): void;
-};
-
-const createStorage =
-  typeof window === "undefined" || !window.localStorage
-    ? createMemoryDataStore
-    : createLocalStorageDataStore
-
-export const storage = createStorage("wasp");
-
-function createMemoryDataStore(prefix: string): DataStore {
-  const store: Map<string, unknown> = new Map();
-
-  function getPrefixedKey(key: string): string {
-    return `${prefix}:${key}`;
-  }
-
-  return {
-    getPrefixedKey,
-    set(key, value) {
-      store.set(getPrefixedKey(key), value);
-    },
-    get(key) {
-      return store.get(getPrefixedKey(key));
-    },
-    remove(key) {
-      store.delete(getPrefixedKey(key));
-    },
-    clear() {
-      store.clear();
-    },
-  };
-}
-
-function createLocalStorageDataStore(prefix: string): DataStore {
-  if (!window.localStorage) {
-    throw new Error("Local storage is not available.");
-  }
-
-  function getPrefixedKey(key: string): string {
-    return `${prefix}:${key}`;
-  }
-
-  return {
-    getPrefixedKey,
-    set(key, value) {
-      localStorage.setItem(getPrefixedKey(key), JSON.stringify(value));
-    },
-    get(key) {
-      const value = localStorage.getItem(getPrefixedKey(key));
-      try {
-        return value ? JSON.parse(value) : undefined;
-      } catch (e: any) {
-        return undefined;
-      }
-    },
-    remove(key) {
-      localStorage.removeItem(getPrefixedKey(key));
-    },
-    clear() {
-      Object.keys(localStorage).forEach((key) => {
-        if (key.startsWith(prefix)) {
-          localStorage.removeItem(key);
-        }
-      });
-    },
-  };
-}

package/data/Generator/templates/sdk/wasp/env/validation.ts

@@ -1,44 +0,0 @@
-import * as z from "zod";
-
-import { colorize } from "../universal/ansiColors.js";
-
-// PRIVATE API (SDK)
-export function ensureEnvSchema<Schema extends z.ZodType>(
-  data: unknown,
-  schema: Schema,
-): z.infer<Schema> {
-  const result = getValidatedEnvOrError(data, schema);
-  if (result.success) {
-    return result.data;
-  } else {
-    console.error(colorize("red", formatZodEnvError(result.error)));
-    throw new Error("Error parsing environment variables");
-  }
-}
-
-// PRIVATE API (SDK, Vite config)
-export function getValidatedEnvOrError<Schema extends z.ZodType>(
-  env: unknown,
-  schema: Schema,
-): z.ZodSafeParseResult<z.infer<Schema>> {
-  return schema.safeParse(env);
-}
-
-// PRIVATE API (SDK, Vite config)
-export function formatZodEnvError(error: z.ZodError): string {
-  const flattenedIssues = z.flattenError(error);
-
-  return [
-    "══ Env vars validation failed ══",
-    "",
-    // Top-level errors
-    ...flattenedIssues.formErrors,
-    "",
-    // Errors per field
-    ...Object.entries(flattenedIssues.fieldErrors).map(
-      ([prop, error]) => `${prop} - ${error}`,
-    ),
-    "",
-    "════════════════════════════════",
-  ].join("\n");
-}

package/data/Generator/templates/sdk/wasp/server/HttpError.ts

@@ -1,30 +0,0 @@
-export class HttpError extends Error {
-  public statusCode: number
-  public data: unknown
-
-  constructor(
-    statusCode: number,
-    message?: string,
-    data?: Record<string, unknown>,
-    options?: ErrorOptions
-  ) {
-    super(message, options)
-
-    if (Error.captureStackTrace) {
-      Error.captureStackTrace(this, HttpError)
-    }
-
-    this.name = this.constructor.name
-
-    if (
-      !(Number.isInteger(statusCode) && statusCode >= 400 && statusCode < 600)
-    ) {
-      throw new Error('statusCode has to be integer in range [400, 600).')
-    }
-    this.statusCode = statusCode
-
-    if (data) {
-      this.data = data
-    }
-  }
-}

package/data/Generator/templates/sdk/wasp/server/auth/oauth/provider.ts

@@ -1,20 +0,0 @@
-import { OAuth2Provider, OAuth2ProviderWithPKCE } from "arctic";
-
-export function defineProvider<
-  OAuthClient extends OAuth2Provider | OAuth2ProviderWithPKCE,
-  const Id extends string
->({
-  id,
-  displayName,
-  oAuthClient,
-}: {
-  id: Id;
-  displayName: string;
-  oAuthClient: OAuthClient;
-}) {
-  return {
-    id,
-    displayName,
-    oAuthClient,
-  };
-}