@wasp.sh/wasp-cli-darwin-arm64-unknown 0.20.0

package/data/packages/ts-inspect/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "wasp-ts-inspect",
+  "version": "0.0.1",
+  "type": "module",
+  "author": "Wasp Team",
+  "license": "MIT",
+  "bin": "dist/index.js",
+  "main": "dist/index.js",
+  "scripts": {
+    "build": "npx tsc",
+    "start": "node ./dist/index.js",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "dependencies": {
+    "json5": "^2.2.3",
+    "typescript": "^5.1.3",
+    "zod": "^3.21.4"
+  },
+  "devDependencies": {
+    "@types/node": "^22.17.0",
+    "@typescript-eslint/eslint-plugin": "^5.48.0",
+    "@typescript-eslint/parser": "^5.48.0",
+    "eslint": "^8.31.0",
+    "vitest": "^4.0.8"
+  },
+  "//": [
+    "typescript is purposefully a normal dependency, and not a dev dependency:",
+    "the compiler is called at runtime to extract information from JS/TS files."
+  ]
+}

package/data/packages/wasp-config/dist/__tests__/appAnalyzer.unit.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=appAnalyzer.unit.test.d.ts.map

package/data/packages/wasp-config/dist/__tests__/appAnalyzer.unit.test.d.ts.map

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

package/data/packages/wasp-config/dist/__tests__/appAnalyzer.unit.test.js

@@ -0,0 +1,59 @@
+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 * as Fixtures from "./testFixtures.js";
+describe("analyzeApp", () => {
+    afterEach(() => vi.clearAllMocks());
+    test("should parse minimal app sucessfully", async () => {
+        await testAnalyzeApp({
+            app: Fixtures.createApp("minimal").app,
+            entities: Fixtures.getEntities("minimal"),
+        });
+    });
+    test("should parse full app sucessfully", async () => {
+        await testAnalyzeApp({
+            app: Fixtures.createApp("full").app,
+            entities: Fixtures.getEntities("full"),
+        });
+    });
+    test("should return an error if the default export is not defined", async () => {
+        await testAnalyzeApp({
+            app: undefined,
+            entities: Fixtures.getEntities("minimal"),
+            options: {
+                shouldReturnError: true,
+            },
+        });
+    });
+    test("should return an error if the default export is not an instance of App", async () => {
+        await testAnalyzeApp({
+            app: "not an instance of App",
+            entities: Fixtures.getEntities("minimal"),
+            options: {
+                shouldReturnError: true,
+            },
+        });
+    });
+    async function testAnalyzeApp(input) {
+        const { app, entities, options: { shouldReturnError } = { shouldReturnError: false }, } = input;
+        const mockMainWaspTs = "main.wasp.ts";
+        vi.doMock(mockMainWaspTs, () => ({ default: app }));
+        const result = await analyzeApp(mockMainWaspTs, entities);
+        if (shouldReturnError) {
+            expect(result).toMatchObject({
+                status: "error",
+                error: expect.anything(),
+            });
+        }
+        else {
+            const tsAppSpec = app[GET_TS_APP_SPEC]();
+            const appSpecDecls = mapTsAppSpecToAppSpecDecls(tsAppSpec, entities);
+            expect(result).toMatchObject({
+                status: "ok",
+                value: appSpecDecls,
+            });
+        }
+    }
+});

package/data/packages/wasp-config/dist/__tests__/cli.unit.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=cli.unit.test.d.ts.map

package/data/packages/wasp-config/dist/__tests__/cli.unit.test.d.ts.map

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

package/data/packages/wasp-config/dist/__tests__/cli.unit.test.js

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

package/data/packages/wasp-config/dist/__tests__/mapTsAppSpecToAppSpecDecls.integration.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=mapTsAppSpecToAppSpecDecls.integration.test.d.ts.map

package/data/packages/wasp-config/dist/__tests__/mapTsAppSpecToAppSpecDecls.integration.test.d.ts.map

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

package/data/packages/wasp-config/dist/__tests__/mapTsAppSpecToAppSpecDecls.integration.test.js

@@ -0,0 +1,126 @@
+/* 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 * as Fixtures from "./testFixtures.js";
+describe("mapTsAppSpecToAppSpecDecls", () => {
+    test("should map full app using mapping functions correctly", () => {
+        const { appConfigName, app } = Fixtures.createApp("full");
+        const tsAppSpec = app[GET_TS_APP_SPEC]();
+        const entities = Fixtures.getEntities("full");
+        const entityRefParser = makeRefParser("Entity", entities);
+        const routeRefParser = makeRefParser("Route", Fixtures.getRouteConfigs().map((r) => r.name));
+        const pageRefParser = makeRefParser("Page", Fixtures.getPageConfigs().map((p) => p.name));
+        const appDeclType = "App";
+        const result = mapTsAppSpecToAppSpecDecls(tsAppSpec, entities);
+        const appDecl = getDecl(result, appDeclType, appConfigName);
+        expect(appDecl).toStrictEqual({
+            declType: appDeclType,
+            declName: appConfigName,
+            declValue: mapApp(tsAppSpec.app.config, entityRefParser, routeRefParser, tsAppSpec.auth, tsAppSpec.client, tsAppSpec.server, tsAppSpec.db, tsAppSpec.emailSender, tsAppSpec.websocket),
+        });
+        expectCorrectDeclMapping({
+            declType: "Page",
+            decls: tsAppSpec.pages,
+            expectedMapping: {
+                function: mapPage,
+            },
+            actualMapping: result,
+        });
+        expectCorrectDeclMapping({
+            declType: "Route",
+            decls: tsAppSpec.routes,
+            expectedMapping: {
+                function: mapRoute,
+                extraArgs: [pageRefParser],
+            },
+            actualMapping: result,
+        });
+        expectCorrectDeclMapping({
+            declType: "Query",
+            decls: tsAppSpec.queries,
+            expectedMapping: {
+                function: mapOperation,
+                extraArgs: [entityRefParser],
+            },
+            actualMapping: result,
+        });
+        expectCorrectDeclMapping({
+            declType: "Action",
+            decls: tsAppSpec.actions,
+            expectedMapping: {
+                function: mapOperation,
+                extraArgs: [entityRefParser],
+            },
+            actualMapping: result,
+        });
+        expectCorrectDeclMapping({
+            declType: "Crud",
+            decls: tsAppSpec.cruds,
+            expectedMapping: {
+                function: mapCrud,
+                extraArgs: [entityRefParser],
+            },
+            actualMapping: result,
+        });
+        expectCorrectDeclMapping({
+            declType: "ApiNamespace",
+            decls: tsAppSpec.apiNamespaces,
+            expectedMapping: {
+                function: mapApiNamespace,
+            },
+            actualMapping: result,
+        });
+        expectCorrectDeclMapping({
+            declType: "Api",
+            decls: tsAppSpec.apis,
+            expectedMapping: {
+                function: mapApi,
+                extraArgs: [entityRefParser],
+            },
+            actualMapping: result,
+        });
+        expectCorrectDeclMapping({
+            declType: "Job",
+            decls: tsAppSpec.jobs,
+            expectedMapping: {
+                function: mapJob,
+                extraArgs: [entityRefParser],
+            },
+            actualMapping: result,
+        });
+    });
+    test("should map minimal app using mapping functions correctly", () => {
+        const { appConfigName, app } = Fixtures.createApp("minimal");
+        const tsAppSpec = app[GET_TS_APP_SPEC]();
+        const entities = Fixtures.getEntities("minimal");
+        const entityRefParser = makeRefParser("Entity", entities);
+        const routeRefParser = makeRefParser("Route", []);
+        const appDeclType = "App";
+        const result = mapTsAppSpecToAppSpecDecls(tsAppSpec, entities);
+        const appDecl = getDecl(result, appDeclType, appConfigName);
+        expect(appDecl).toStrictEqual({
+            declType: appDeclType,
+            declName: appConfigName,
+            declValue: mapApp(tsAppSpec.app.config, entityRefParser, routeRefParser, tsAppSpec.auth, tsAppSpec.server, tsAppSpec.client, tsAppSpec.db, tsAppSpec.emailSender, tsAppSpec.websocket),
+        });
+    });
+    function expectCorrectDeclMapping({ declType, decls, expectedMapping, actualMapping, }) {
+        const { function: mappingFn, extraArgs = [] } = expectedMapping;
+        decls.forEach((config, name) => {
+            const resultDecl = getDecl(actualMapping, declType, name);
+            expect(resultDecl).toStrictEqual({
+                declType,
+                declName: name,
+                declValue: mappingFn(config, ...extraArgs),
+            });
+        });
+    }
+    /**
+     * Retrieves a specific declaration from a list of declarations based on its type and name.
+     */
+    function getDecl(decls, declType, declName) {
+        const decl = decls.find((decl) => decl.declType === declType && decl.declName === declName);
+        return decl;
+    }
+});

package/data/packages/wasp-config/dist/__tests__/mapTsAppSpecToAppSpecDecls.unit.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=mapTsAppSpecToAppSpecDecls.unit.test.d.ts.map

package/data/packages/wasp-config/dist/__tests__/mapTsAppSpecToAppSpecDecls.unit.test.d.ts.map

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