@wasp.sh/wasp-cli-darwin-arm64-unknown 0.23.0 → 0.24.0-rc.2

package/data/Generator/templates/sdk/wasp/client/env/schema.ts

@@ -28,12 +28,12 @@ const waspProdClientEnvSchema = z.object({
   "{= serverUrlEnvVarName =}": serverUrlSchema,
 });
 
+const waspClientEnvSchema = import.meta.env.MODE === "production"
+  ? waspProdClientEnvSchema
+  : waspDevClientEnvSchema;
+
 // PRIVATE API (sdk, Vite config)
-// TODO(franjo): Remove passing mode as param when this is no longer a plugin.
-//               See: https://github.com/wasp-lang/wasp/issues/3875.
-export function getClientEnvSchema(mode: string) {
-  const waspClientEnvSchema = mode === "production"
-    ? waspProdClientEnvSchema
-    : waspDevClientEnvSchema;
-  return z.object({ ...userClientEnvSchema.shape, ...waspClientEnvSchema.shape })
-}
+export const clientEnvSchema = z.object({
+  ...userClientEnvSchema.shape,
+  ...waspClientEnvSchema.shape,
+});

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

@@ -1,8 +1,8 @@
 import { ensureEnvSchema } from "../env/validation.js";
-import { getClientEnvSchema } from "./env/schema.js";
+import { clientEnvSchema } from "./env/schema.js";
 
 // PUBLIC API
 export const env = ensureEnvSchema(
   import.meta.env,
-  getClientEnvSchema(import.meta.env.MODE),
+  clientEnvSchema,
 );

package/data/Generator/templates/sdk/wasp/client/operations/internal/index.ts

@@ -9,8 +9,10 @@ export type OperationRoute = { method: HttpMethod.Post, path: string }
 export async function callOperation(operationRoute: OperationRoute, args: any) {
   try {
     const serializedArgs = serialize(args)
-    const response = await api.post(operationRoute.path, serializedArgs)
-    return deserialize(response.data)
+    const json = await api.post(operationRoute.path, {
+      json: serializedArgs,
+    }).json()
+    return deserialize(json as any)
   } catch (error) {
     throw handleApiError(error)
   }

package/data/Generator/templates/sdk/wasp/client/router/NavLink.tsx

@@ -0,0 +1,21 @@
+import { useMemo } from 'react'
+import { NavLink as RouterNavLink } from 'react-router'
+import { interpolatePath } from './linkHelpers'
+import { type Routes } from './index'
+
+type RouterNavLinkProps = Parameters<typeof RouterNavLink>[0]
+
+// PUBLIC API
+export function NavLink(
+  { to, params, search, hash, ...restOfProps }: Omit<RouterNavLinkProps, "to">
+  & {
+    search?: Record<string, string>;
+    hash?: string;
+  }
+  & Routes
+): React.JSX.Element {
+  const toPropWithParams = useMemo(() => {
+    return interpolatePath(to, params, search, hash)
+  }, [to, params, search, hash])
+  return <RouterNavLink to={toPropWithParams} {...restOfProps} />
+}

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

@@ -51,3 +51,5 @@ export type Routes = RouteDefinitionsToRoutes<typeof routes>
 
 // PUBLIC API
 export { Link } from './Link'
+// PUBLIC API
+export { NavLink } from './NavLink'

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

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

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

@@ -1,54 +1,82 @@
-import { type Plugin } from "vite";
-
+{{={= =}=}}
+import path from "node:path";
 import {
-  formatZodEnvError,
-  getValidatedEnvOrError,
-} from "../../../env/validation.js";
-import { colorize } from "../../../universal/ansiColors.js";
-import { getClientEnvSchema } from "../../env/schema.js";
-import { loadEnvVars } from "./envFile.js";
+  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 validationResult: ReturnType<typeof getValidatedEnvOrError> | null = null;
+  let resolvedConfig: ResolvedConfig;
+
   return {
-    name: "wasp:validate-env",
-    async configResolved(config) {
-      const env = await loadEnvVars({
-        rootDir: config.root,
-        // 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: config.command === "serve",
+    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 tepomrary 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)
+          // 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,
       });
-      const schema = getClientEnvSchema(config.mode);
-      validationResult = getValidatedEnvOrError(env, schema);
 
-      // Exit if we are in build mode, because we can't show the error in the browser.
-      if (config.command === "build" && !validationResult.success) {
-        const validationErrorMessage = formatZodEnvError(validationResult.error);
-        console.error(colorize("red", validationErrorMessage));
-        process.exit(1);
+      try {
+        // Vite's `ssr` means bundled for "backend JS runtime", like Node.
+        // This envrionemnt 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();
       }
     },
-    configureServer: (server) => {
-      if (validationResult === null || validationResult.success) {
-        return;
-      }
-
-      // Send the error to the browser.
-      const validationErrorMessage = formatZodEnvError(validationResult.error);
-      server.ws.on("connection", () => {
-        server.ws.send({
-          type: "error",
-          err: {
-            message: validationErrorMessage,
-            stack: "",
-          },
-        });
-      });
-    },
   };
 }

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

@@ -27,7 +27,7 @@ export function wasp(options?: WaspPluginOptions): PluginOption {
     /**
      * Plugins running after core Vite plugins.
      */
-    typescriptCheck(),
+    typescriptCheck({ srcTsConfigPath: "{= srcTsConfigPath =}" }),
     validateEnv(),
     react(options?.reactOptions),
     ssr({

package/data/Generator/templates/sdk/wasp/tsconfig.json

@@ -94,5 +94,8 @@
     // web-app runtime via Vite virtual modules. That's why we don't want the
     // SDK to compile them.
     "client/vite/virtual-files/files",
+    // Wasp spec files shouldn't be compiled by the SDK because they are used to
+    // configure Wasp and not part of the SDK runtime.
+    "**/*.wasp.ts",
   ]
 }

package/data/Generator/templates/types/spec/register.ts

@@ -0,0 +1,14 @@
+{{={= =}=}}
+// The import ensures the module is always loaded into the bundle.
+// Otherwise, module augmentation can fail if it wasn't loaded.
+import "{= waspSpecPackageName =}";
+
+declare module "{= waspSpecPackageName =}" {
+  export interface Register {
+    entities: {
+{=# entities =}
+      {= name =}: "{= name =}";
+{=/ entities =}
+    }
+  }
+}

package/data/packages/deploy/dist/providers/railway/commands/setup/setup.js

@@ -9,6 +9,7 @@ import { getRailwayEnvVarValueReference } from "../../env.js";
 import { clientAppPort, serverAppPort } from "../../ports.js";
 import { initRailwayProject, linkRailwayProjectToWaspProjectDir, } from "../../railwayProject/cli.js";
 import { getRailwayProjectStatus, ProjectStatus, } from "../../railwayProject/index.js";
+import { waitForServiceDeploymentSuccess } from "../../railwayService/deployment.js";
 import { generateServiceUrl } from "../../railwayService/url.js";
 export async function setup(projectName, options) {
     waspSays("Setting up your Wasp app with Railway!");
@@ -99,6 +100,11 @@ async function setupDb({ cmdOptions: options, dbServiceName, }) {
         // Use the default Railway Postgres template.
         await railwayCli(["add", "-d", "postgres"]);
     }
+    // The database service deploys asynchronously and `railway add` doesn't wait
+    // for it. The server service references the database's DATABASE_URL env
+    // variable, and Railway references to a service that isn't fully set up
+    // silently resolve to an empty string and never recover.
+    await waitForServiceDeploymentSuccess(dbServiceName, options);
 }
 async function setupServer({ cmdOptions: options, serverServiceName, clientServiceName, dbServiceName, }) {
     waspSays(`Setting up server app with name ${serverServiceName}`);
@@ -139,6 +145,9 @@ async function setupClient({ cmdOptions: options, clientServiceName, }) {
         "add",
         ["--service", clientServiceName],
         ["--variables", `PORT=${clientAppPort}`],
+        // So Railpack detects the output as static files even when there's not an
+        // `index.html`.
+        ["--variables", `RAILPACK_STATIC_FILE_ROOT=1`],
         ...options.clientSecret.map((secret) => ["--variables", secret]),
     ].flat());
     waspSays("Client setup complete!");

package/data/packages/deploy/dist/providers/railway/jsonOutputSchemas.js

@@ -13,6 +13,53 @@ export const RailwayCliProjectSchema = z.object({
     }),
 });
 export const RailwayProjectListSchema = z.array(RailwayCliProjectSchema);
+export const DeploymentStatusSchema = z.enum([
+    "BUILDING",
+    "CRASHED",
+    "DEPLOYING",
+    "FAILED",
+    "INITIALIZING",
+    "NEEDS_APPROVAL",
+    "QUEUED",
+    "REMOVED",
+    "REMOVING",
+    "SKIPPED",
+    "SLEEPING",
+    "SUCCESS",
+    "WAITING",
+]);
+const GroupedServiceInstancesSchema = z.object({
+    edges: z.array(z.object({
+        node: z.object({
+            serviceInstances: z.object({
+                edges: z.array(z.object({
+                    node: z.object({
+                        serviceName: z.string(),
+                        latestDeployment: z
+                            .object({
+                            status: DeploymentStatusSchema,
+                        })
+                            .nullish(),
+                    }),
+                })),
+            }),
+        }),
+    })),
+});
+// Railway CLI >=4.35 nests service instances under `environments`.
+const NewFormatProjectStatusSchema = z.object({
+    environments: GroupedServiceInstancesSchema,
+});
+// Older Railway CLI versions (e.g. 4.11) nest service instances under `services`.
+const OldFormatProjectStatusSchema = z.object({
+    services: GroupedServiceInstancesSchema,
+});
+export const RailwayCliProjectStatusSchema = z.union([
+    NewFormatProjectStatusSchema,
+    OldFormatProjectStatusSchema.transform(({ services }) => ({
+        environments: services,
+    })),
+]);
 export const RailwayCliDomainSchema = z.union([
     // Railway CLI >=4.18.1
     z.object({ domains: z.array(z.string()).min(1) }),

package/data/packages/deploy/dist/providers/railway/railwayService/deployment.js

@@ -0,0 +1,45 @@
+import { setTimeout } from "node:timers/promises";
+import { waspSays } from "../../../common/terminal.js";
+import { createCommandWithCwd } from "../../../common/zx.js";
+import { RailwayCliProjectStatusSchema, } from "../jsonOutputSchemas.js";
+const POLL_INTERVAL_MS = 5000;
+const TIMEOUT_MS = 5 * 60 * 1000;
+// Any other status means the deployment is still in progress.
+const SUCCESS_STATUS = "SUCCESS";
+const FAILURE_STATUSES = ["FAILED", "CRASHED"];
+export async function waitForServiceDeploymentSuccess(serviceName, options) {
+    const deadline = Date.now() + TIMEOUT_MS;
+    while (Date.now() < deadline) {
+        const status = await getLatestServiceDeploymentStatus(serviceName, options);
+        if (status === SUCCESS_STATUS) {
+            return;
+        }
+        if (status !== null && FAILURE_STATUSES.includes(status)) {
+            throw new Error(`"${serviceName}" deployment finished with status "${status}". Check the Railway dashboard for details.`);
+        }
+        waspSays(`Waiting for "${serviceName}" deployment... (Status: "${status ?? "UNKNOWN"}")`);
+        await setTimeout(POLL_INTERVAL_MS);
+    }
+    throw new Error(`Timed out waiting for "${serviceName}" to be deployed. Check the Railway dashboard for details.`);
+}
+async function getLatestServiceDeploymentStatus(serviceName, options) {
+    const railwayCli = createCommandWithCwd(options.railwayExe, options.waspProjectDir);
+    const result = await railwayCli(["status", "--json"], {
+        verbose: false,
+        nothrow: true,
+    });
+    if (result.exitCode !== 0) {
+        // Treat transient `railway status` failures as "not ready yet".
+        return null;
+    }
+    const projectStatus = RailwayCliProjectStatusSchema.parse(result.json());
+    return findServiceDeploymentStatus(projectStatus, serviceName);
+}
+export function findServiceDeploymentStatus(projectStatus, serviceName) {
+    const serviceInstance = projectStatus.environments.edges
+        .flatMap((environment) => environment.node.serviceInstances.edges)
+        .map((edge) => edge.node)
+        .find((instance) => instance.serviceName === serviceName);
+    return serviceInstance?.latestDeployment?.status ?? null;
+}
+//# sourceMappingURL=deployment.js.map

package/data/packages/deploy/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "wasp-deploy",
-  "version": "0.0.1",
+  "version": "0.24.0",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "wasp-deploy",
-      "version": "0.0.1",
+      "version": "0.24.0",
       "license": "MIT",
       "dependencies": {
         "@inquirer/prompts": "^7.5.3",

package/data/packages/deploy/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wasp-deploy",
-  "version": "0.0.1",
+  "version": "0.24.0",
   "type": "module",
   "author": "Wasp Team",
   "license": "MIT",

package/data/packages/prisma/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "wasp-prisma",
-  "version": "0.0.1",
+  "version": "0.24.0",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "wasp-prisma",
-      "version": "0.0.1",
+      "version": "0.24.0",
       "license": "MIT",
       "dependencies": {
         "json5": "^2.2.3",

package/data/packages/prisma/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wasp-prisma",
-  "version": "0.0.1",
+  "version": "0.24.0",
   "type": "module",
   "author": "Wasp Team",
   "license": "MIT",
@@ -13,7 +13,6 @@
   },
   "dependencies": {
     "json5": "^2.2.3",
-    "prisma": "Prisma version here needs to be kept in sync with prisma version used in wasp-cli.",
     "prisma": "5.19.1",
     "strip-ansi": "^7.1.2",
     "tmp-promise": "3.0.3"

package/data/packages/spec/dist/__tests__/cli.unit.test.js

@@ -0,0 +1,128 @@
+import { describe, expect, test } from "vitest";
+import { parseProcessArgsOrThrow } from "../src/cli.js";
+describe("parseProcessArgsOrThrow", () => {
+    test("should parse arguments correctly", () => {
+        expectParseProcessArgsToSucceed([
+            "analyze",
+            "main.wasp.ts",
+            "tsconfig.wasp.json",
+            "/project",
+            "output.json",
+            JSON.stringify(["entity1"]),
+        ]);
+    });
+    test("should parse 0 entities correctly", () => {
+        expectParseProcessArgsToSucceed([
+            "analyze",
+            "main.wasp.ts",
+            "tsconfig.wasp.json",
+            "/project",
+            "output.json",
+            "[]",
+        ]);
+    });
+    test("should throw an error if less than 8 arguments", () => {
+        expectParseProcessArgsToError([
+            "analyze",
+            "main.wasp.ts",
+            "tsconfig.wasp.json",
+            "/project",
+            "output.json",
+        ]);
+    });
+    test("should throw an error if more than 8 arguments", () => {
+        expectParseProcessArgsToError([
+            "analyze",
+            "main.wasp.ts",
+            "tsconfig.wasp.json",
+            "/project",
+            "output.json",
+            "[]",
+            "extraArg",
+        ]);
+    });
+    test("should throw an error if command is unsupported", () => {
+        expectParseProcessArgsToError([
+            "compile",
+            "main.wasp.ts",
+            "tsconfig.wasp.json",
+            "/project",
+            "output.json",
+            "[]",
+        ]);
+    });
+    test("should throw an error if waspTsSpecPath is not a string", () => {
+        expectParseProcessArgsToError([
+            "analyze",
+            undefined,
+            "tsconfig.wasp.json",
+            "/project",
+            "output.json",
+            JSON.stringify(["entity1"]),
+        ]);
+    });
+    test("should throw an error if tsconfigPath is not a string", () => {
+        expectParseProcessArgsToError([
+            "analyze",
+            "main.wasp.ts",
+            undefined,
+            "/project",
+            "output.json",
+            JSON.stringify(["entity1"]),
+        ]);
+    });
+    test("should throw an error if projectRootDir is not a string", () => {
+        expectParseProcessArgsToError([
+            "analyze",
+            "main.wasp.ts",
+            "tsconfig.wasp.json",
+            undefined,
+            "output.json",
+            JSON.stringify(["entity1"]),
+        ]);
+    });
+    test("should throw an error if specResultPath is not a string", () => {
+        expectParseProcessArgsToError([
+            "analyze",
+            "main.wasp.ts",
+            "tsconfig.wasp.json",
+            "/project",
+            undefined,
+            JSON.stringify(["entity1"]),
+        ]);
+    });
+    test("should throw an error if any entityNames is not a string", () => {
+        expectParseProcessArgsToError([
+            "analyze",
+            "main.wasp.ts",
+            "tsconfig.wasp.json",
+            "/project",
+            "output.json",
+            undefined,
+        ]);
+    });
+    test("should throw an error if the entity names JSON is not an array", () => {
+        expectParseProcessArgsToError([
+            "analyze",
+            "main.wasp.ts",
+            "tsconfig.wasp.json",
+            "/project",
+            "output.json",
+            JSON.stringify({ entity1: "entity1" }),
+        ]);
+    });
+    function expectParseProcessArgsToSucceed(args) {
+        const result = parseProcessArgsOrThrow(["node", "run.js", ...args]);
+        const [_command, waspTsSpecPath, tsconfigPath, projectRootDir, specResultPath, entityNames,] = args;
+        expect(result).toEqual({
+            waspTsSpecPath,
+            tsconfigPath,
+            projectRootDir,
+            specResultPath,
+            entityNames: entityNames && JSON.parse(entityNames),
+        });
+    }
+    function expectParseProcessArgsToError(args) {
+        expect(() => parseProcessArgsOrThrow(["node", "run.js", ...args])).toThrowError();
+    }
+});

package/data/packages/spec/dist/__tests__/legacy/appAnalyzer.unit.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"appAnalyzer.unit.test.d.ts","sourceRoot":"","sources":["../../../__tests__/legacy/appAnalyzer.unit.test.ts"],"names":[],"mappings":""}

package/data/packages/{wasp-config/dist/__tests__ → spec/dist/__tests__/legacy}/appAnalyzer.unit.test.js

@@ -1,8 +1,8 @@
 import { afterEach } from "node:test";
 import { describe, expect, test, vi } from "vitest";
-import { GET_TS_APP_SPEC } from "../src/_private.js";
-import { analyzeApp } from "../src/appAnalyzer.js";
-import { mapTsAppSpecToAppSpecDecls } from "../src/mapTsAppSpecToAppSpecDecls.js";
+import { GET_TS_APP_SPEC } from "../../src/legacy/_private.js";
+import { analyzeApp } from "../../src/legacy/appAnalyzer.js";
+import { mapTsAppSpecToAppSpecDecls } from "../../src/legacy/mapTsAppSpecToAppSpecDecls.js";
 import * as Fixtures from "./testFixtures.js";
 describe("analyzeApp", () => {
     afterEach(() => vi.clearAllMocks());

package/data/packages/spec/dist/__tests__/legacy/mapTsAppSpecToAppSpecDecls.integration.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mapTsAppSpecToAppSpecDecls.integration.test.d.ts","sourceRoot":"","sources":["../../../__tests__/legacy/mapTsAppSpecToAppSpecDecls.integration.test.ts"],"names":[],"mappings":""}

package/data/packages/{wasp-config/dist/__tests__ → spec/dist/__tests__/legacy}/mapTsAppSpecToAppSpecDecls.integration.test.js

@@ -1,7 +1,7 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import { describe, expect, test } from "vitest";
-import { GET_TS_APP_SPEC } from "../src/_private.js";
-import { makeRefParser, mapApi, mapApiNamespace, mapApp, mapCrud, mapJob, mapOperation, mapPage, mapRoute, mapTsAppSpecToAppSpecDecls, } from "../src/mapTsAppSpecToAppSpecDecls.js";
+import { GET_TS_APP_SPEC } from "../../src/legacy/_private.js";
+import { makeRefParser, mapApi, mapApiNamespace, mapApp, mapCrud, mapJob, mapOperation, mapPage, mapRoute, mapTsAppSpecToAppSpecDecls, } from "../../src/legacy/mapTsAppSpecToAppSpecDecls.js";
 import * as Fixtures from "./testFixtures.js";
 describe("mapTsAppSpecToAppSpecDecls", () => {
     test("should map full app using mapping functions correctly", () => {

package/data/packages/spec/dist/__tests__/legacy/mapTsAppSpecToAppSpecDecls.unit.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mapTsAppSpecToAppSpecDecls.unit.test.d.ts","sourceRoot":"","sources":["../../../__tests__/legacy/mapTsAppSpecToAppSpecDecls.unit.test.ts"],"names":[],"mappings":""}