@unisian/start 0.3.0 → 0.4.0

package/dist/liquid.d.mts

@@ -0,0 +1,12 @@
+import * as Schema from "effect/Schema";
+import { ReactNode } from "react";
+//#region src/liquid.d.ts
+export declare const liquid: (raw: string) => string;
+export declare const t: (key: string, args?: Readonly<Record<string, string>>) => string;
+export declare const stylesheet: (asset: string) => string;
+export declare const script: (asset: string) => string;
+export declare const renderSnippet: (name: string, params: Readonly<Record<string, string | number | boolean | null | undefined>>) => string;
+declare const UnswappedLiquidToken_base: Schema.Class<UnswappedLiquidToken, Schema.TaggedStruct<"UnswappedLiquidToken", {}>, import("effect/Cause").YieldableError>;
+export declare class UnswappedLiquidToken extends UnswappedLiquidToken_base {}
+export declare const renderAppProxyPage: (node: ReactNode) => string;
+//#endregion

package/dist/liquid.mjs

@@ -0,0 +1,37 @@
+import * as Predicate from "effect/Predicate";
+import * as Schema from "effect/Schema";
+import { Base64, Hex } from "effect/encoding";
+import * as Result from "effect/Result";
+import { renderToStaticMarkup } from "react-dom/server";
+//#region src/liquid.ts
+const liquidNonce = (() => {
+	let nonce;
+	return () => {
+		nonce ??= Hex.encode(crypto.getRandomValues(/* @__PURE__ */ new Uint8Array(16)));
+		return nonce;
+	};
+})();
+const tokenPattern = () => new RegExp(`@@LQ${liquidNonce()}\\.([A-Za-z0-9+/=]+)@@`, "gu");
+const liquid = (raw) => `@@LQ${liquidNonce()}.${Base64.encode(raw)}@@`;
+const openerPattern = () => new RegExp(`\\{(?=[{%]|@@LQ${liquidNonce()}\\.)`, "gu");
+const defuseTags = (markup) => markup.replace(openerPattern(), "{");
+const liquidLiteral = (value) => value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll("\"", "&quot;").replaceAll("'", "’").replaceAll("{", "&#123;").replaceAll("}", "&#125;");
+const t = (key, args = {}) => {
+	const argSource = Object.entries(args).map(([name, value]) => ` ${name}: '${liquidLiteral(value)}'`).join(",");
+	return liquid(`{{ '${key}' | ${argSource === "" ? "t" : `t:${argSource}`} }}`);
+};
+const stylesheet = (asset) => liquid(`{{ '${asset}' | asset_url | stylesheet_tag }}`);
+const script = (asset) => liquid(`<script src="{{ '${asset}' | asset_url }}" type="module" data-ot-ignore><\/script>`);
+const renderSnippet = (name, params) => {
+	const args = Object.entries(params).filter(([, value]) => value !== null && value !== void 0 && value !== "").map(([key, value]) => Predicate.isString(value) ? `${key}: '${liquidLiteral(value)}'` : `${key}: ${String(value)}`).join(", ");
+	return liquid(`{% render '${name}'${args === "" ? "" : `, ${args}`} %}`);
+};
+const authored = (base64) => Result.getOrElse(Base64.decodeString(base64), () => "");
+var UnswappedLiquidToken = class extends Schema.TaggedError()("UnswappedLiquidToken", {}) {};
+const renderAppProxyPage = (node) => {
+	const page = defuseTags(renderToStaticMarkup(node)).replace(tokenPattern(), (_token, base64) => authored(base64));
+	if (page.includes(`@@LQ${liquidNonce()}.`)) throw new UnswappedLiquidToken();
+	return page;
+};
+//#endregion
+export { UnswappedLiquidToken, liquid, renderAppProxyPage, renderSnippet, script, stylesheet, t };

package/dist/proxy-input-rejected.mjs

@@ -0,0 +1,5 @@
+import * as Schema from "effect/Schema";
+//#region src/proxy-input-rejected.ts
+var ProxyInputRejected = class extends Schema.TaggedError()("ProxyInputRejected", { cause: Schema.Defect() }) {};
+//#endregion
+export { ProxyInputRejected };

package/dist/proxy-responses.d.mts

@@ -0,0 +1,17 @@
+import * as Schema from "effect/Schema";
+//#region src/proxy-responses.d.ts
+export declare const proxyJson: (data: Schema.Json, init?: ResponseInit) => Response;
+declare const proxyErrorStatus: {
+  readonly "bad-request": 400;
+  readonly forbidden: 403;
+  readonly internal: 500;
+  readonly "not-found": 404;
+  readonly unauthorized: 401;
+};
+export type ProxyErrorCode = keyof typeof proxyErrorStatus;
+export declare const proxyError: (code: ProxyErrorCode, message: string) => Response;
+export declare const proxyLiquid: (body: string, init?: ResponseInit) => Response;
+export declare const LAYOUT_NONE = "{% layout none %}";
+export declare const proxyRedirect: (location: string) => Response;
+export declare const proxySaveRedirect: (location: string, fetched: boolean) => Response;
+//#endregion

package/dist/proxy-responses.mjs

@@ -0,0 +1,39 @@
+//#region src/proxy-responses.ts
+const proxyJson = (data, init = {}) => {
+	const headers = new Headers(init.headers);
+	headers.set("Content-Type", "application/json; charset=utf-8");
+	headers.set("Cache-Control", "no-store");
+	return Response.json(data, {
+		...init,
+		headers
+	});
+};
+const proxyErrorStatus = {
+	"bad-request": 400,
+	forbidden: 403,
+	internal: 500,
+	"not-found": 404,
+	unauthorized: 401
+};
+const proxyError = (code, message) => proxyJson({ error: {
+	code,
+	message
+} }, { status: proxyErrorStatus[code] });
+const proxyLiquid = (body, init = {}) => {
+	const headers = new Headers(init.headers);
+	headers.set("Content-Type", "application/liquid");
+	headers.set("Cache-Control", "no-store");
+	headers.set("X-Robots-Tag", "noindex");
+	return new Response(body, {
+		...init,
+		headers
+	});
+};
+const LAYOUT_NONE = "{% layout none %}";
+const proxyRedirect = (location) => new Response(null, {
+	headers: { Location: location },
+	status: 302
+});
+const proxySaveRedirect = (location, fetched) => fetched ? proxyJson({ location }) : proxyRedirect(location);
+//#endregion
+export { LAYOUT_NONE, proxyError, proxyJson, proxyLiquid, proxyRedirect, proxySaveRedirect };

package/dist/proxy.d.mts

@@ -0,0 +1,54 @@
+import { LAYOUT_NONE, ProxyErrorCode, proxyError, proxyJson, proxyLiquid, proxyRedirect, proxySaveRedirect } from "./proxy-responses.mjs";
+import * as Schema from "effect/Schema";
+import { AnyContract, Capability } from "@unisian/capability";
+import { RequestLogTags, RequestReference } from "@unisian/effect-observability";
+import { CurrentCustomer, CurrentShop, LoggedInCustomer, ShopifyAdmin, ShopifyApp, ShopifyLayerConfig, ShopifyStorefront, StorefrontOperation } from "@unisian/shopify-auth";
+import * as Layer from "effect/Layer";
+import { HttpClient } from "effect/http";
+//#region src/proxy.d.ts
+export interface ProxyServeConfig<Services, ServicesError> extends ShopifyLayerConfig {
+  readonly appProxyPath: string;
+  readonly storefrontOperations: Readonly<Record<string, StorefrontOperation>>;
+  readonly services?: Layer.Layer<Services, ServicesError> | undefined;
+}
+export type AnyoneProvided<Services> = CurrentShop | CurrentCustomer | ShopifyAdmin | ShopifyStorefront | ShopifyApp | HttpClient.HttpClient | RequestReference | Services;
+export type LoggedInProvided<Services> = AnyoneProvided<Services> | LoggedInCustomer;
+export interface StorefrontLinks {
+  readonly login: (returnPath?: string) => string;
+  readonly url: (path: string) => string;
+}
+export type ProxyAnswer<Output> = {
+  readonly answer: "json";
+} | {
+  readonly answer: "page";
+  readonly render: (output: Output) => string;
+} | {
+  readonly answer: "fragment";
+  readonly render: (output: Output) => string;
+} | {
+  readonly answer: "redirect";
+  readonly location: (output: Output, storefront: StorefrontLinks) => string;
+  readonly fetchField?: string | undefined;
+};
+type ProxyOptions<Output, Failure> = ProxyAnswer<Output> & {
+  readonly refuse?: ((failure: Failure, storefront: StorefrontLinks) => Response) | undefined;
+};
+type RefuseWhenFailing<Failure> = [Failure] extends [never] ? unknown : {
+  readonly refuse: (failure: Failure, storefront: StorefrontLinks) => Response;
+};
+export type ProxyOptionsFor<ContractType extends AnyContract> = ProxyOptions<ContractType["output"]["Type"], ContractType["failure"]["Type"]> & RefuseWhenFailing<ContractType["failure"]["Type"]>;
+export interface ProxyCall {
+  readonly request: Request;
+  readonly context: {
+    readonly log: RequestLogTags;
+  };
+  readonly params?: Readonly<Record<string, string>> | undefined;
+}
+export type ProxyField = Schema.Json | File | readonly (string | File)[];
+export type ProxyFields = Readonly<Record<string, ProxyField>>;
+export declare const makeProxyServe: <Services = never, ServicesError = never>(config: () => ProxyServeConfig<Services, ServicesError>) => {
+  anyone: <ContractType extends AnyContract, Requirements extends AnyoneProvided<Services>>(capability: Capability<ContractType, Requirements>, options: ProxyOptionsFor<ContractType>) => ({ request, context: { log }, params }: ProxyCall) => Promise<Response>;
+  loggedIn: <ContractType extends AnyContract, Requirements extends LoggedInProvided<Services>>(capability: Capability<ContractType, Requirements>, options: ProxyOptionsFor<ContractType>) => ({ request, context: { log }, params }: ProxyCall) => Promise<Response>;
+};
+//#endregion
+export { LAYOUT_NONE, type ProxyErrorCode, proxyError, proxyJson, proxyLiquid, proxyRedirect, proxySaveRedirect };

package/dist/proxy.mjs

@@ -0,0 +1,104 @@
+import { respond } from "./middleware.mjs";
+import { ProxyInputRejected } from "./proxy-input-rejected.mjs";
+import { LAYOUT_NONE, proxyError, proxyJson, proxyLiquid, proxyRedirect, proxySaveRedirect } from "./proxy-responses.mjs";
+import * as Schema from "effect/Schema";
+import * as Option from "effect/Option";
+import { RequestReference, logFailure } from "@unisian/effect-observability";
+import { LoggedInCustomer, ShopifyAdmin, ShopifyStorefront, StorefrontOperationRegistry, appProxyIdentity, shopifyLayer, verifyAppProxy } from "@unisian/shopify-auth";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+//#region src/proxy.ts
+const shopifyQueryKeys = /* @__PURE__ */ new Set([
+	"logged_in_customer_id",
+	"path_prefix",
+	"shop",
+	"signature",
+	"timestamp"
+]);
+const fieldsOf = (entries) => {
+	const fields = /* @__PURE__ */ new Map();
+	for (const [key, value] of entries) if (!shopifyQueryKeys.has(key)) {
+		const earlier = fields.get(key);
+		fields.set(key, earlier === void 0 ? value : [...[earlier].flat(), value]);
+	}
+	return Object.fromEntries(fields);
+};
+const decodeJsonBody = Schema.decodeUnknownEffect(Schema.Record(Schema.String, Schema.Json));
+const rejected = (cause) => new ProxyInputRejected({ cause });
+const isForm = (type) => type.startsWith("application/x-www-form-urlencoded") || type.startsWith("multipart/form-data");
+const bodyFields = (request) => {
+	const type = request.headers.get("content-type") ?? "";
+	if (type.startsWith("application/json")) return Effect.tryPromise({
+		catch: rejected,
+		try: () => request.json()
+	}).pipe(Effect.flatMap(decodeJsonBody), Effect.mapError(rejected));
+	if (isForm(type)) return Effect.tryPromise({
+		catch: rejected,
+		try: () => request.formData()
+	}).pipe(Effect.map((form) => fieldsOf(form.entries())));
+	return Effect.succeed({});
+};
+const buyerIp = (request) => {
+	const first = request.headers.get("x-forwarded-for")?.split(",")[0]?.trim() ?? "";
+	return first === "" ? null : first;
+};
+const visitedPath = (request, proxy, appProxyPath) => {
+	const url = new URL(request.url);
+	const query = new URLSearchParams([...url.searchParams].filter(([key]) => !shopifyQueryKeys.has(key))).toString();
+	return `${proxy.pathPrefix}${url.pathname.slice(appProxyPath.length)}${query === "" ? "" : `?${query}`}`;
+};
+const storefrontLinks = (request, proxy, appProxyPath) => {
+	const host = request.headers.get("x-forwarded-host") ?? proxy.shop;
+	const url = (path) => `https://${host}${path}`;
+	return {
+		login: (returnPath = visitedPath(request, proxy, appProxyPath)) => url(`/account/login?return_url=${encodeURIComponent(returnPath)}`),
+		url
+	};
+};
+const fetchedSave = (answer, fields) => answer.answer === "redirect" && answer.fetchField !== void 0 && fields[answer.fetchField] === "1";
+const answerWith = (answer, output, encoded, fields, storefront) => {
+	if (answer.answer === "json") return proxyJson(encoded);
+	if (answer.answer === "page") return proxyLiquid(answer.render(output));
+	if (answer.answer === "fragment") return proxyLiquid(`${LAYOUT_NONE}${answer.render(output)}`);
+	return proxySaveRedirect(answer.location(output, storefront), fetchedSave(answer, fields));
+};
+const loggedOutAnswer = (answer, fields, storefront) => answer.answer === "page" || answer.answer === "redirect" && !fetchedSave(answer, fields) ? proxyRedirect(storefront.login()) : proxyError("unauthorized", "Login required");
+const project = (config) => (contract, options, run) => {
+	const decodeInput = Schema.decodeUnknownEffect(contract.input);
+	const encodeOutput = Schema.encodeEffect(Schema.toCodecJson(contract.output));
+	const isFailure = Schema.is(contract.failure);
+	const refuseWith = (storefront) => (failure) => options.refuse === void 0 ? Effect.die(failure) : Effect.succeed(options.refuse(failure, storefront));
+	return ({ request, context: { log }, params = {} }) => {
+		const { appProxyPath, services, storefrontOperations, ...shopify } = config();
+		const layerFor = (proxy) => Layer.mergeAll(appProxyIdentity(proxy), ShopifyAdmin.layerForShop(proxy.shop), ShopifyStorefront.layerForShop(proxy.shop, buyerIp(request)), Layer.succeed(RequestReference, { reference: log.reference }), services ?? Layer.empty).pipe(Layer.orDie);
+		const served = Effect.gen(function* serveProxy() {
+			const proxy = yield* verifyAppProxy(request);
+			const body = yield* bodyFields(request);
+			const fields = {
+				...fieldsOf(new URL(request.url).searchParams),
+				...body,
+				...params
+			};
+			const handler = run(proxy);
+			const storefront = storefrontLinks(request, proxy, appProxyPath);
+			if (Option.isNone(handler)) return loggedOutAnswer(options, fields, storefront);
+			const input = yield* decodeInput(fields).pipe(Effect.mapError(rejected));
+			return yield* handler.value(input).pipe(Effect.flatMap((output) => Effect.orDie(encodeOutput(output)).pipe(Effect.map((encoded) => answerWith(options, output, encoded, fields, storefront)))), Effect.catchIf(isFailure, refuseWith(storefront)), Effect.provide(layerFor(proxy)));
+		}).pipe(Effect.catchTags({
+			InvalidAppProxy: (error) => Effect.logWarning("app proxy request rejected", { reason: error.reason }).pipe(Effect.as(proxyError("unauthorized", "Invalid app proxy signature"))),
+			ProxyInputRejected: () => Effect.succeed(proxyError("bad-request", "Invalid input"))
+		}), Effect.provide(Layer.mergeAll(shopifyLayer(shopify), StorefrontOperationRegistry.layer(storefrontOperations))), Effect.tapCause((cause) => logFailure("app proxy", cause)));
+		return respond(contract.name, log, () => proxyError("internal", `Something went wrong. Reference: ${log.reference}`))(served);
+	};
+};
+const makeProxyServe = (config) => {
+	const projectWith = project(config);
+	const anyone = (capability, options) => projectWith(capability.contract, options, () => Option.some((input) => capability.handler(input)));
+	const loggedIn = (capability, options) => projectWith(capability.contract, options, (proxy) => proxy.customer.pipe(Option.map((customer) => (input) => capability.handler(input).pipe(Effect.provideService(LoggedInCustomer, { customer })))));
+	return {
+		anyone,
+		loggedIn
+	};
+};
+//#endregion
+export { LAYOUT_NONE, makeProxyServe, proxyError, proxyJson, proxyLiquid, proxyRedirect, proxySaveRedirect };

package/dist/serve.d.mts

@@ -4,8 +4,8 @@ import { AnyContract, Capability, InputOf } from "@unisian/capability";
 import { RequestLogTags, RequestReference } from "@unisian/effect-observability";
 import { AuthenticatedShop, CurrentShop, ShopifyAdmin, ShopifyApp, ShopifyLayerConfig } from "@unisian/shopify-auth";
 import * as Layer from "effect/Layer";
-import { ShopDomain } from "@unisian/shopify-sessions";
 import { HttpClient } from "effect/http";
+import { ShopDomain } from "@unisian/shopify-sessions";
 //#region src/serve.d.ts
 export interface ServeContext {
   readonly shopify: AuthenticatedShop;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@unisian/start",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -16,7 +16,9 @@
     "./react": "./dist/client.mjs",
     "./serve": "./dist/serve.mjs",
     "./middleware": "./dist/middleware.mjs",
-    "./function-id": "./dist/function-id.mjs"
+    "./function-id": "./dist/function-id.mjs",
+    "./proxy": "./dist/proxy.mjs",
+    "./liquid": "./dist/liquid.mjs"
   },
   "publishConfig": {
     "access": "public"
@@ -31,11 +33,12 @@
     "@tanstack/react-start": "1.168.60",
     "effect": "4.0.6",
     "react": "19.3.0",
+    "react-dom": "19.3.0",
     "vite": "npm:@voidzero-dev/vite-plus-core@1.1.0",
-    "@unisian/capability": "0.3.0",
-    "@unisian/effect-observability": "0.3.0",
-    "@unisian/shopify-auth": "0.3.0",
-    "@unisian/shopify-sessions": "0.3.0"
+    "@unisian/capability": "0.4.0",
+    "@unisian/effect-observability": "0.4.0",
+    "@unisian/shopify-auth": "0.4.0",
+    "@unisian/shopify-sessions": "0.4.0"
   },
   "peerDependencies": {
     "@tanstack/react-query": "^5.104.1",
@@ -44,10 +47,11 @@
     "@tanstack/react-start": "^1.168.60",
     "effect": "^4.0.2",
     "react": "^19.3.0",
-    "@unisian/effect-observability": "0.3.0",
-    "@unisian/shopify-auth": "0.3.0",
-    "@unisian/shopify-sessions": "0.3.0",
-    "@unisian/capability": "0.3.0"
+    "react-dom": "^19.3.0",
+    "@unisian/capability": "0.4.0",
+    "@unisian/effect-observability": "0.4.0",
+    "@unisian/shopify-sessions": "0.4.0",
+    "@unisian/shopify-auth": "0.4.0"
   },
   "scripts": {}
 }