@by-association-only/harness-app 0.0.1-placeholder → 0.1.1

package/dist/branch-XrPxkmYQ.mjs

@@ -0,0 +1,37 @@
+import { isBranchName } from "@by-association-only/harness-unisian/stages";
+import * as Option from "effect/Option";
+import * as Data from "effect/Data";
+//#region src/router/branch.ts
+const branchCookie = "__Host-branch";
+const branchParam = "branch";
+const switchPath = "/__branch/";
+const cookieMaxAgeSeconds = 604800;
+const cookieAttributes = "Path=/; Secure; HttpOnly; SameSite=None; Partitioned";
+const setBranchCookie = (branch) => `${branchCookie}=${branch}; ${cookieAttributes}; Max-Age=${cookieMaxAgeSeconds}`;
+const clearBranchCookie = `${branchCookie}=; ${cookieAttributes}; Max-Age=0`;
+const branchIn = (routerHost, value) => isBranchName(routerHost, value) ? Option.some(value) : Option.none();
+const cookieBranch = (request, routerHost) => Option.fromNullishOr(request.headers.get("cookie")).pipe(Option.flatMap((header) => Option.fromNullishOr(header.split(";").map((pair) => pair.trim()).find((pair) => pair.startsWith(`${branchCookie}=`)))), Option.flatMap((pair) => branchIn(routerHost, pair.slice(14))));
+const { Chosen, Default, Invalid, Switch } = Data.taggedEnum();
+const chooseBranch = (request, routerHost) => {
+	const url = new URL(request.url);
+	const fromValue = (value, onValid) => Option.match(branchIn(routerHost, value), {
+		onNone: () => Invalid({ value }),
+		onSome: onValid
+	});
+	if (url.pathname.startsWith("/__branch/")) return fromValue(url.pathname.slice(10), (branch) => Switch({ branch }));
+	const param = url.searchParams.get(branchParam);
+	if (param === "") return Default({ setCookie: clearBranchCookie });
+	if (param !== null) return fromValue(param, (branch) => Chosen({
+		branch,
+		setCookie: setBranchCookie(branch)
+	}));
+	return Option.match(cookieBranch(request, routerHost), {
+		onNone: () => Default({ setCookie: null }),
+		onSome: (branch) => Chosen({
+			branch,
+			setCookie: null
+		})
+	});
+};
+//#endregion
+export { switchPath as i, chooseBranch as n, setBranchCookie as r, branchCookie as t };

package/dist/function-tests.d.mts

@@ -0,0 +1,7 @@
+//#region src/function-tests.d.ts
+export interface FunctionFixtures {
+  readonly instructionBudget: number;
+  readonly testsDir: string;
+}
+export declare const testFunctionFixtures: ({ instructionBudget, testsDir }: FunctionFixtures) => void;
+//#endregion

package/dist/function-tests.mjs

@@ -0,0 +1,41 @@
+import { readdirSync } from "node:fs";
+import path from "node:path";
+import { buildFunction, getFunctionInfo, loadFixture, loadInputQuery, loadSchema, runFunction, validateTestAssets } from "@shopify/shopify-function-test-helpers";
+import * as Schema from "effect/Schema";
+import { assert, beforeAll, describe, expect, test } from "vite-plus/test";
+//#region src/function-tests.ts
+const Targeting = Schema.Record(Schema.String, Schema.Struct({ inputQueryPath: Schema.String }));
+const testFunctionFixtures = ({ instructionBudget, testsDir }) => {
+	if (!Number.isInteger(instructionBudget) || instructionBudget <= 0) throw new Error(`instructionBudget must be a whole number above 0, not ${instructionBudget}.`);
+	const functionDir = path.dirname(testsDir);
+	const fixturesDir = path.join(testsDir, "fixtures");
+	const fixtureFiles = readdirSync(fixturesDir).filter((file) => file.endsWith(".json")).toSorted();
+	if (fixtureFiles.length === 0) throw new Error(`${fixturesDir} has no .json fixture, so nothing tests this Function.`);
+	const built = {};
+	describe(path.basename(functionDir), () => {
+		beforeAll(async () => {
+			await buildFunction(functionDir);
+			built.info = await getFunctionInfo(functionDir);
+		}, 12e4);
+		test.each(fixtureFiles)(`runs %s within ${instructionBudget} instructions`, async (file) => {
+			const info = built.info ?? assert.fail("the Function wasn't built");
+			const fixture = await loadFixture(path.join(fixturesDir, file));
+			const inputQueryPath = Schema.decodeUnknownSync(Targeting)(info.targeting)[fixture.target]?.inputQueryPath ?? assert.fail(`the Function has no target ${fixture.target}`);
+			const validation = await validateTestAssets({
+				fixture,
+				inputQueryAST: await loadInputQuery(inputQueryPath),
+				schema: await loadSchema(info.schemaPath)
+			});
+			expect(validation.inputQuery.errors).toEqual([]);
+			expect(validation.inputFixture.errors).toEqual([]);
+			expect(validation.outputFixture.errors).toEqual([]);
+			const run = await runFunction(fixture, info.functionRunnerPath, info.wasmPath, inputQueryPath, info.schemaPath);
+			expect(run.error).toBeNull();
+			expect(run.result?.output).toEqual(fixture.expectedOutput);
+			const instructions = run.metadata?.instructionCount ?? assert.fail("function-runner reported no instruction count");
+			expect(instructions, `${file} ran ${instructions} instructions, over the Function's budget of ${instructionBudget}`).toBeLessThanOrEqual(instructionBudget);
+		});
+	});
+};
+//#endregion
+export { testFunctionFixtures };

package/dist/harness.d.mts

@@ -0,0 +1,98 @@
+import * as Schema from "effect/Schema";
+import { Command } from "effect/cli";
+import { ChildProcessSpawner } from "effect/process";
+//#region src/codegen/check.d.ts
+declare const CodegenCheckFailed_base: Schema.Class<CodegenCheckFailed, Schema.TaggedStruct<"CodegenCheckFailed", {
+  readonly reason: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+declare class CodegenCheckFailed extends CodegenCheckFailed_base {
+  get message(): string;
+}
+//#endregion
+//#region src/failed.d.ts
+declare const CommandFailed_base: Schema.Class<CommandFailed, Schema.TaggedStruct<"CommandFailed", {
+  readonly reason: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+declare class CommandFailed extends CommandFailed_base {
+  get message(): string;
+}
+//#endregion
+//#region src/harness.d.ts
+declare const _default: {
+  blocks: import("@by-association-only/harness/layer").LayerBlock[];
+  checkSteps: string[];
+  testSteps: string[];
+  commands: (import("effect/cli/Command").Command<"codegen-check", {}, {}, CodegenCheckFailed, import("effect/process/ChildProcessSpawner").ChildProcessSpawner> | import("effect/cli/Command").Command<"destroy", {}, {}, CommandFailed, import("effect/process/ChildProcessSpawner").ChildProcessSpawner | import("effect/FileSystem").FileSystem | import("effect/Path").Path> | import("effect/cli/Command").Command<"dev", {
+    readonly shopifyArgs: readonly string[];
+  }, {}, CommandFailed, import("effect/process/ChildProcessSpawner").ChildProcessSpawner | import("effect/FileSystem").FileSystem | import("effect/Path").Path> | import("effect/cli/Command").Command<"env-check", {}, {}, CommandFailed, import("effect/process/ChildProcessSpawner").ChildProcessSpawner> | import("effect/cli/Command").Command<"functions", {}, {}, CommandFailed, import("effect/process/ChildProcessSpawner").ChildProcessSpawner> | import("effect/cli/Command").Command<"pull-env", {}, {}, CommandFailed, import("effect/process/ChildProcessSpawner").ChildProcessSpawner> | import("effect/cli/Command").Command<"rust", {}, {}, CommandFailed, import("effect/process/ChildProcessSpawner").ChildProcessSpawner> | import("effect/cli/Command").Command<"slot", {}, {}, CommandFailed, import("effect/process/ChildProcessSpawner").ChildProcessSpawner | import("effect/FileSystem").FileSystem | import("effect/Path").Path> | import("effect/cli/Command").Command<"stage", {
+    readonly config: string;
+  }, {}, CommandFailed, import("effect/process/ChildProcessSpawner").ChildProcessSpawner | import("effect/FileSystem").FileSystem | import("effect/Path").Path>)[];
+  pieces: ({
+    blocks: {
+      file: string;
+      id: string;
+      slot: string;
+      text: string;
+    }[];
+    when: {
+      dependency: string;
+      file?: undefined;
+    };
+  } | {
+    blocks: {
+      file: string;
+      id: string;
+      slot: string;
+      text: string;
+    }[];
+    when: {
+      dependency?: undefined;
+      file: string;
+    };
+  })[];
+  verify: {
+    commands: import("effect/cli/Command").Command<string, {
+      readonly [x: string]: unknown;
+    }, {}, import("@by-association-only/harness/verify").EvidenceFailed | import("@by-association-only/harness/verify").VerifyFailed, import("effect/process/ChildProcessSpawner").ChildProcessSpawner | import("effect/FileSystem").FileSystem | import("effect/Path").Path>[];
+    doctor: import("effect/Effect").Effect<{
+      app: {
+        apiKey: string;
+        handle: string;
+        title: string;
+      };
+      shop: {
+        domain: string;
+        name: string;
+      };
+      apiVersion: string;
+      config: string;
+      devStore: string | null;
+      scopes: string[];
+      tokenExpiresAt: string;
+      evidence: string;
+    }, import("@by-association-only/harness/verify").EvidenceFailed | import("@by-association-only/harness/verify").VerifyFailed, import("effect/FileSystem").FileSystem | import("effect/Path").Path>;
+    doctorFlags: {
+      app: string;
+      shop: string;
+    };
+    settings: {
+      refusedFramingHint: string;
+    };
+    steps: {
+      branch: import("@by-association-only/harness/verify").FlowStep<{
+        readonly app: import("effect/Schema").optional<import("effect/Schema").String>;
+        readonly headed: import("effect/Schema").optional<import("effect/Schema").Boolean>;
+        readonly name: import("effect/Schema").String;
+      }, import("effect/FileSystem").FileSystem | import("effect/Path").Path>;
+    };
+    surfaces: import("effect/Effect").Effect<string[], import("effect/PlatformError").BadArgument | {
+      message: string;
+    }, import("effect/FileSystem").FileSystem | import("effect/Path").Path>;
+  };
+  worktree: {
+    postCreate: string[];
+    preRemove: string[];
+  };
+};
+//#endregion
+export { _default as default };