@unisian/shopify-admin 0.0.0 → 0.6.0

package/dist/access-token-rejected.d.mts

@@ -0,0 +1,10 @@
+import * as Schema from "effect/Schema";
+//#region src/access-token-rejected.d.ts
+declare const AccessTokenRejected_base: Schema.Class<AccessTokenRejected, Schema.TaggedStruct<"AccessTokenRejected", {
+  readonly operation: Schema.String;
+  readonly shop: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class AccessTokenRejected extends AccessTokenRejected_base {
+  get message(): string;
+}
+//#endregion

package/dist/access-token-rejected.mjs

@@ -0,0 +1,12 @@
+import * as Schema from "effect/Schema";
+//#region src/access-token-rejected.ts
+var AccessTokenRejected = class extends Schema.TaggedError()("AccessTokenRejected", {
+	operation: Schema.String,
+	shop: Schema.String
+}) {
+	get message() {
+		return `Admin API rejected the access token for ${this.shop} (HTTP 401 on ${this.operation})`;
+	}
+};
+//#endregion
+export { AccessTokenRejected };

package/dist/admin-api.d.mts

@@ -0,0 +1,45 @@
+import { AccessTokenRejected } from "./access-token-rejected.mjs";
+import { AdminOperationRegistry } from "./admin-operation-registry.mjs";
+import { AdminQueryFailed } from "./admin-query-failed.mjs";
+import { AdminDocument, AdminOperations } from "./operations.mjs";
+import * as Schema from "effect/Schema";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Redacted from "effect/Redacted";
+import { HttpClient } from "effect/http";
+import { AuthenticatedShop, ExchangeError, RefreshError, SessionOwner, ShopifyApp, ShopifyAuth } from "@unisian/shopify-auth";
+import { VariablesArgsFor } from "@unisian/shopify-auth/kernel";
+import { ShopDomain } from "@unisian/shopify-sessions";
+//#region src/admin-api.d.ts
+export interface AdminCredential {
+  readonly accessToken: Redacted.Redacted;
+  readonly shop: ShopDomain;
+}
+export interface AdminDocumentResult {
+  readonly data: Schema.Json | null;
+  readonly errors: readonly Schema.Json[];
+  readonly extensions: Schema.Json | null;
+  readonly status: number;
+}
+export declare const sendAdminDocument: (apiVersion: string, credential: AdminCredential, document: string, variables: Readonly<Record<string, Schema.Json>>) => Effect.Effect<AdminDocumentResult, AdminQueryFailed | AccessTokenRejected, HttpClient.HttpClient>;
+export type VariablesArgs<Q extends AdminDocument> = VariablesArgsFor<AdminOperations[Q]["variables"]>;
+export type AdminError = AdminQueryFailed | AccessTokenRejected | ExchangeError | RefreshError;
+declare const ShopifyAdmin_base: Context.ServiceClass<ShopifyAdmin, "@unisian/shopify-admin/ShopifyAdmin", {
+  readonly graphql: <const Q extends AdminDocument>(document: Q, ...variables: VariablesArgs<Q>) => Effect.Effect<AdminOperations[Q]["data"], AdminError>;
+}>;
+export declare class ShopifyAdmin extends ShopifyAdmin_base {
+  static readonly make: (authenticated: AuthenticatedShop) => Effect.Effect<{
+    readonly graphql: <const Q extends AdminDocument>(document: Q, ...variables: VariablesArgs<Q>) => Effect.Effect<AdminOperations[Q]["data"], AdminError>;
+  }, never, AdminOperationRegistry | HttpClient.HttpClient | ShopifyApp | ShopifyAuth>;
+  static readonly layer: (authenticated: AuthenticatedShop) => Layer.Layer<ShopifyAdmin, never, AdminOperationRegistry | HttpClient.HttpClient | ShopifyApp | ShopifyAuth>;
+  static readonly makeForShop: (shop: ShopDomain) => Effect.Effect<{
+    readonly graphql: <const Q extends AdminDocument>(document: Q, ...variables: VariablesArgs<Q>) => Effect.Effect<AdminOperations[Q]["data"], AdminError>;
+  }, never, AdminOperationRegistry | HttpClient.HttpClient | SessionOwner | ShopifyApp>;
+  static readonly layerForShop: (shop: ShopDomain) => Layer.Layer<ShopifyAdmin, never, AdminOperationRegistry | HttpClient.HttpClient | SessionOwner | ShopifyApp>;
+  static readonly makeForToken: (credential: AdminCredential, apiVersion: string) => Effect.Effect<{
+    readonly graphql: <const Q extends AdminDocument>(document: Q, ...variables: VariablesArgs<Q>) => Effect.Effect<AdminOperations[Q]["data"], AdminError>;
+  }, never, AdminOperationRegistry | HttpClient.HttpClient>;
+  static readonly layerForToken: (credential: AdminCredential, apiVersion: string) => Layer.Layer<ShopifyAdmin, never, AdminOperationRegistry | HttpClient.HttpClient>;
+}
+//#endregion

package/dist/admin-api.mjs

@@ -0,0 +1,103 @@
+import { AccessTokenRejected } from "./access-token-rejected.mjs";
+import { AdminOperationRegistry } from "./admin-operation-registry.mjs";
+import { AdminQueryFailed } from "./admin-query-failed.mjs";
+import * as Schema from "effect/Schema";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Redacted from "effect/Redacted";
+import * as Ref from "effect/Ref";
+import { HttpClient, HttpClientRequest, HttpClientResponse } from "effect/http";
+import { SessionOwner, ShopifyApp, ShopifyAuth, withoutRequest } from "@unisian/shopify-auth";
+import { logRenewal, operationBody, operationData, operationFor } from "@unisian/shopify-auth/kernel";
+//#region src/admin-api.ts
+const adminRequest = (apiVersion, credential, body) => HttpClientRequest.post(`https://${credential.shop}/admin/api/${apiVersion}/graphql.json`).pipe(HttpClientRequest.acceptJson, HttpClientRequest.setHeader("X-Shopify-Access-Token", Redacted.value(credential.accessToken)), HttpClientRequest.bodyJsonUnsafe(body));
+const AdminDocumentBody = Schema.Struct({
+	data: Schema.optional(Schema.NullOr(Schema.Json)),
+	errors: Schema.optional(Schema.Array(Schema.Json)),
+	extensions: Schema.optional(Schema.Json)
+});
+const sendAdminDocument = (apiVersion, credential, document, variables) => Effect.gen(function* sendAdminDocumentGen() {
+	const operation = "an ad hoc document";
+	const failed = (cause) => new AdminQueryFailed({
+		cause: withoutRequest(cause),
+		operation,
+		shop: credential.shop
+	});
+	const response = yield* (yield* HttpClient.HttpClient).execute(adminRequest(apiVersion, credential, {
+		query: document,
+		variables
+	})).pipe(Effect.mapError(failed));
+	if (response.status === 401) return yield* new AccessTokenRejected({
+		operation,
+		shop: credential.shop
+	});
+	const body = yield* HttpClientResponse.schemaBodyJson(AdminDocumentBody)(response).pipe(Effect.mapError(failed));
+	return {
+		data: body.data ?? null,
+		errors: body.errors ?? [],
+		extensions: body.extensions ?? null,
+		status: response.status
+	};
+}).pipe(Effect.withSpan("sendAdminDocument"));
+const adminQuery = (apiVersion, session, operation, variables) => Effect.gen(function* sendAdminQuery() {
+	const failed = (cause) => new AdminQueryFailed({
+		cause: withoutRequest(cause),
+		operation: operation.name,
+		shop: session.shop
+	});
+	const client = yield* HttpClient.HttpClient;
+	const body = yield* operationBody(operation, variables, failed);
+	const response = yield* client.execute(adminRequest(apiVersion, session, body)).pipe(Effect.mapError(failed));
+	if (response.status === 401) return yield* new AccessTokenRejected({
+		operation: operation.name,
+		shop: session.shop
+	});
+	return yield* operationData(operation.data, failed)(response);
+}).pipe(Effect.withSpan("adminQuery", { attributes: { operation: operation.name } }));
+const sendForShop = (shop) => Effect.gen(function* sendForShopGen() {
+	const { apiVersion } = yield* ShopifyApp;
+	const client = yield* HttpClient.HttpClient;
+	const owner = yield* SessionOwner;
+	const send = (operation, variables) => owner.stored(shop).pipe(Effect.tap(logRenewal), Effect.flatMap(({ session }) => adminQuery(apiVersion, session, operation, variables)), Effect.annotateLogs("shop", shop), Effect.provideService(HttpClient.HttpClient, client));
+	return send;
+});
+const sendForToken = (credential, apiVersion) => Effect.gen(function* sendForTokenGen() {
+	const client = yield* HttpClient.HttpClient;
+	const send = (operation, variables) => adminQuery(apiVersion, credential, operation, variables).pipe(Effect.annotateLogs("shop", credential.shop), Effect.provideService(HttpClient.HttpClient, client));
+	return send;
+});
+const graphqlOver = (registry, send) => (document, ...[variables]) => {
+	return operationFor(registry, document).pipe(Effect.flatMap((operation) => send(operation, variables ?? {})));
+};
+var ShopifyAdmin = class ShopifyAdmin extends Context.Service()("@unisian/shopify-admin/ShopifyAdmin") {
+	static make = (authenticated) => Effect.gen(function* make() {
+		const { apiVersion } = yield* ShopifyApp;
+		const registry = yield* AdminOperationRegistry;
+		const client = yield* HttpClient.HttpClient;
+		const auth = yield* ShopifyAuth;
+		const session = yield* Ref.make(authenticated.session);
+		const graphql = (document, ...[variables]) => {
+			return operationFor(registry, document).pipe(Effect.flatMap((operation) => {
+				const run = Ref.get(session).pipe(Effect.flatMap((current) => adminQuery(apiVersion, current, operation, variables ?? {})));
+				return run.pipe(Effect.catchTag("AccessTokenRejected", () => auth.reexchange(authenticated).pipe(Effect.flatMap((renewed) => Ref.set(session, renewed)), Effect.andThen(run))));
+			}), Effect.provideService(HttpClient.HttpClient, client));
+		};
+		return ShopifyAdmin.of({ graphql });
+	});
+	static layer = (authenticated) => Layer.effect(ShopifyAdmin, ShopifyAdmin.make(authenticated));
+	static makeForShop = (shop) => Effect.gen(function* makeForShop() {
+		const registry = yield* AdminOperationRegistry;
+		const send = yield* sendForShop(shop);
+		return ShopifyAdmin.of({ graphql: graphqlOver(registry, send) });
+	});
+	static layerForShop = (shop) => Layer.effect(ShopifyAdmin, ShopifyAdmin.makeForShop(shop));
+	static makeForToken = (credential, apiVersion) => Effect.gen(function* makeForToken() {
+		const registry = yield* AdminOperationRegistry;
+		const send = yield* sendForToken(credential, apiVersion);
+		return ShopifyAdmin.of({ graphql: graphqlOver(registry, send) });
+	});
+	static layerForToken = (credential, apiVersion) => Layer.effect(ShopifyAdmin, ShopifyAdmin.makeForToken(credential, apiVersion));
+};
+//#endregion
+export { ShopifyAdmin, adminQuery, sendAdminDocument, sendForShop, sendForToken };

package/dist/admin-bulk-query-registry.d.mts

@@ -0,0 +1,26 @@
+import * as Schema from "effect/Schema";
+import * as Context from "effect/Context";
+import * as Layer from "effect/Layer";
+//#region src/admin-bulk-query-registry.d.ts
+export interface BulkLines {
+  readonly line: Schema.Codec<unknown, unknown>;
+  readonly connections: Readonly<Record<string, BulkConnection>>;
+}
+export interface BulkConnection extends BulkLines {
+  readonly path: readonly string[];
+  readonly types: readonly string[];
+}
+export interface AdminBulkQuery extends BulkLines {
+  readonly name: string;
+  readonly kind: "bulk";
+  readonly document: readonly string[];
+  readonly slots: readonly string[];
+  readonly enums: readonly string[];
+  readonly parameters: Schema.Codec<unknown, unknown>;
+  readonly node: Schema.Codec<unknown, unknown>;
+}
+declare const AdminBulkQueryRegistry_base: Context.ServiceClass<AdminBulkQueryRegistry, "@unisian/shopify-admin/AdminBulkQueryRegistry", Readonly<Record<string, AdminBulkQuery>>>;
+export declare class AdminBulkQueryRegistry extends AdminBulkQueryRegistry_base {
+  static readonly layer: (queries: Readonly<Record<string, AdminBulkQuery>>) => Layer.Layer<AdminBulkQueryRegistry, never, never>;
+}
+//#endregion

package/dist/admin-bulk-query-registry.mjs

@@ -0,0 +1,8 @@
+import * as Context from "effect/Context";
+import * as Layer from "effect/Layer";
+//#region src/admin-bulk-query-registry.ts
+var AdminBulkQueryRegistry = class AdminBulkQueryRegistry extends Context.Service()("@unisian/shopify-admin/AdminBulkQueryRegistry") {
+	static layer = (queries) => Layer.succeed(AdminBulkQueryRegistry, AdminBulkQueryRegistry.of(queries));
+};
+//#endregion
+export { AdminBulkQueryRegistry };

package/dist/admin-operation-registry.d.mts

@@ -0,0 +1,11 @@
+import * as Schema from "effect/Schema";
+import * as Context from "effect/Context";
+import * as Layer from "effect/Layer";
+import { GraphqlOperation } from "@unisian/shopify-auth/kernel";
+//#region src/admin-operation-registry.d.ts
+export type AdminOperation<Data extends Schema.Codec<unknown, unknown> = Schema.Codec<unknown, unknown>, Variables extends Schema.Codec<unknown, unknown> = Schema.Codec<unknown, unknown>> = GraphqlOperation<Data, Variables>;
+declare const AdminOperationRegistry_base: Context.ServiceClass<AdminOperationRegistry, "@unisian/shopify-admin/AdminOperationRegistry", Readonly<Record<string, AdminOperation<Schema.Codec<unknown, unknown, never, never>, Schema.Codec<unknown, unknown, never, never>>>>>;
+export declare class AdminOperationRegistry extends AdminOperationRegistry_base {
+  static readonly layer: (operations: Readonly<Record<string, AdminOperation>>) => Layer.Layer<AdminOperationRegistry, never, never>;
+}
+//#endregion

package/dist/admin-operation-registry.mjs

@@ -0,0 +1,8 @@
+import * as Context from "effect/Context";
+import * as Layer from "effect/Layer";
+//#region src/admin-operation-registry.ts
+var AdminOperationRegistry = class AdminOperationRegistry extends Context.Service()("@unisian/shopify-admin/AdminOperationRegistry") {
+	static layer = (operations) => Layer.succeed(AdminOperationRegistry, AdminOperationRegistry.of(operations));
+};
+//#endregion
+export { AdminOperationRegistry };

package/dist/admin-query-failed.d.mts

@@ -0,0 +1,11 @@
+import * as Schema from "effect/Schema";
+//#region src/admin-query-failed.d.ts
+declare const AdminQueryFailed_base: Schema.Class<AdminQueryFailed, Schema.TaggedStruct<"AdminQueryFailed", {
+  readonly cause: Schema.Defect;
+  readonly operation: Schema.String;
+  readonly shop: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class AdminQueryFailed extends AdminQueryFailed_base {
+  get message(): string;
+}
+//#endregion

package/dist/admin-query-failed.mjs

@@ -0,0 +1,13 @@
+import * as Schema from "effect/Schema";
+//#region src/admin-query-failed.ts
+var AdminQueryFailed = class extends Schema.TaggedError()("AdminQueryFailed", {
+	cause: Schema.Defect(),
+	operation: Schema.String,
+	shop: Schema.String
+}) {
+	get message() {
+		return `Admin API ${this.operation} failed for ${this.shop}`;
+	}
+};
+//#endregion
+export { AdminQueryFailed };

package/dist/bulk/bulk-operation-refused.d.mts

@@ -0,0 +1,15 @@
+import * as Schema from "effect/Schema";
+//#region src/bulk/bulk-operation-refused.d.ts
+declare const BulkOperationRefused_base: Schema.Class<BulkOperationRefused, Schema.TaggedStruct<"BulkOperationRefused", {
+  readonly operation: Schema.String;
+  readonly shop: Schema.String;
+  readonly userErrors: Schema.$Array<Schema.Struct<{
+    readonly code: Schema.NullOr<Schema.String>;
+    readonly field: Schema.NullOr<Schema.$Array<Schema.String>>;
+    readonly message: Schema.String;
+  }>>;
+}>, import("effect/Cause").YieldableError>;
+export declare class BulkOperationRefused extends BulkOperationRefused_base {
+  get message(): string;
+}
+//#endregion

package/dist/bulk/bulk-operation-refused.mjs

@@ -0,0 +1,18 @@
+import * as Schema from "effect/Schema";
+//#region src/bulk/bulk-operation-refused.ts
+var BulkOperationRefused = class extends Schema.TaggedError()("BulkOperationRefused", {
+	operation: Schema.String,
+	shop: Schema.String,
+	userErrors: Schema.Array(Schema.Struct({
+		code: Schema.NullOr(Schema.String),
+		field: Schema.NullOr(Schema.Array(Schema.String)),
+		message: Schema.String
+	}))
+}) {
+	get message() {
+		const reasons = this.userErrors.map((error) => error.message).join("; ");
+		return `Shopify refused ${this.operation} for ${this.shop}: ${reasons || "no bulk operation came back"}`;
+	}
+};
+//#endregion
+export { BulkOperationRefused };

package/dist/bulk/bulk-operations-finish.d.mts

@@ -0,0 +1,13 @@
+import * as Schema from "effect/Schema";
+//#region src/bulk/bulk-operations-finish.d.ts
+export declare const BULK_OPERATIONS_FINISH_TOPIC = "bulk_operations/finish";
+export declare const BulkOperationsFinish: Schema.Struct<{
+  readonly admin_graphql_api_id: Schema.String;
+  readonly completed_at: Schema.NullOr<Schema.String>;
+  readonly created_at: Schema.String;
+  readonly error_code: Schema.NullOr<Schema.Union<readonly [Schema.StringForLiteralAutocomplete, Schema.Literals<readonly ["access_denied", "internal_server_error", "timeout"]>]>>;
+  readonly status: Schema.Union<readonly [Schema.StringForLiteralAutocomplete, Schema.Literals<readonly ["canceled", "canceling", "completed", "created", "expired", "failed", "running"]>]>;
+  readonly type: Schema.Union<readonly [Schema.StringForLiteralAutocomplete, Schema.Literals<readonly ["mutation", "query"]>]>;
+}>;
+export type BulkOperationsFinish = typeof BulkOperationsFinish.Type;
+//#endregion

package/dist/bulk/bulk-operations-finish.mjs

@@ -0,0 +1,26 @@
+import * as Schema from "effect/Schema";
+//#region src/bulk/bulk-operations-finish.ts
+const BULK_OPERATIONS_FINISH_TOPIC = "bulk_operations/finish";
+const lowercase = (values) => Schema.Union([Schema.StringForLiteralAutocomplete, Schema.Literals(values)]);
+const BulkOperationsFinish = Schema.Struct({
+	admin_graphql_api_id: Schema.String,
+	completed_at: Schema.NullOr(Schema.String),
+	created_at: Schema.String,
+	error_code: Schema.NullOr(lowercase([
+		"access_denied",
+		"internal_server_error",
+		"timeout"
+	])),
+	status: lowercase([
+		"canceled",
+		"canceling",
+		"completed",
+		"created",
+		"expired",
+		"failed",
+		"running"
+	]),
+	type: lowercase(["mutation", "query"])
+});
+//#endregion
+export { BULK_OPERATIONS_FINISH_TOPIC, BulkOperationsFinish };

package/dist/bulk/bulk-result-failed.d.mts

@@ -0,0 +1,10 @@
+import * as Schema from "effect/Schema";
+//#region src/bulk/bulk-result-failed.d.ts
+declare const BulkResultFailed_base: Schema.Class<BulkResultFailed, Schema.TaggedStruct<"BulkResultFailed", {
+  readonly cause: Schema.Defect;
+  readonly operation: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class BulkResultFailed extends BulkResultFailed_base {
+  get message(): string;
+}
+//#endregion

package/dist/bulk/bulk-result-failed.mjs

@@ -0,0 +1,12 @@
+import * as Schema from "effect/Schema";
+//#region src/bulk/bulk-result-failed.ts
+var BulkResultFailed = class extends Schema.TaggedError()("BulkResultFailed", {
+	cause: Schema.Defect(),
+	operation: Schema.String
+}) {
+	get message() {
+		return `Reading the result file of bulk ${this.operation} failed`;
+	}
+};
+//#endregion
+export { BulkResultFailed };

package/dist/bulk/bulk-results.mjs

@@ -0,0 +1,131 @@
+import { BulkResultFailed } from "./bulk-result-failed.mjs";
+import * as Schema from "effect/Schema";
+import * as Effect from "effect/Effect";
+import { HttpClientRequest, HttpClientResponse } from "effect/http";
+import { withoutRequest } from "@unisian/shopify-auth";
+import * as Stream from "effect/Stream";
+import * as Predicate from "effect/Predicate";
+//#region src/bulk/bulk-results.ts
+const ResultLine = Schema.Record(Schema.String, Schema.Json);
+const decodeObject = Schema.decodeUnknownEffect(Schema.fromJsonString(ResultLine));
+const parentIdOf = (line) => Predicate.isString(line.__parentId) ? line.__parentId : void 0;
+const connectionFor = (parent, typename) => Object.entries(parent.connections).find(([, connection]) => Predicate.isString(typename) && connection.types.includes(typename));
+const holdsConnections = (position) => Object.keys(position.connections).length > 0;
+const unplaced = (parentId, typename) => `a ${JSON.stringify(typename ?? null)} line names parent ${parentId}, which no earlier line holds under a connection for that type`;
+const releasedEarly = (parentId, typename) => `${unplaced(parentId, typename)}; nodes folds a root once the next root starts, unless a connection on it holds a multiple of 250 children, which is the order Shopify writes without groupObjects but doesn't promise: submit with { groupObjects: true }, or read the file with lines`;
+const isJsonObject = Schema.is(ResultLine);
+const resultText = (client, url) => url === null ? Stream.empty : client.execute(HttpClientRequest.get(url)).pipe(Effect.flatMap(HttpClientResponse.filterStatusOk), HttpClientResponse.stream, Stream.decodeText, Stream.splitLines, Stream.filter((line) => line.trim() !== ""));
+const bulkLines = (query) => (text) => text.pipe(Stream.mapError((cause) => new BulkResultFailed({
+	cause: withoutRequest(cause),
+	operation: query.name
+})), Stream.mapAccumEffect(() => /* @__PURE__ */ new Map(), (parents, raw) => Effect.gen(function* bulkLine() {
+	const line = yield* decodeObject(raw);
+	const parentId = parentIdOf(line);
+	const parent = parentId === void 0 ? void 0 : parents.get(parentId);
+	const position = parentId === void 0 ? query : parent && connectionFor(parent, line.__typename)?.[1];
+	if (position === void 0) return yield* Effect.fail(unplaced(parentId ?? "", line.__typename));
+	const decoded = yield* Schema.decodeEffect(position.line)(line);
+	if (holdsConnections(position) && Predicate.isString(line.id)) parents.set(line.id, position);
+	return [parents, [decoded]];
+}).pipe(Effect.mapError((cause) => new BulkResultFailed({
+	cause,
+	operation: query.name
+})))));
+const childRunLength = 250;
+const startFolding = (line, position) => ({
+	children: new Map(Object.keys(position.connections).map((key) => [key, []])),
+	line,
+	position
+});
+const mayContinueLater = (folding) => [...folding.children.values()].some((children) => children.length > 0 && children.length % childRunLength === 0 || children.some(mayContinueLater));
+const forget = (byId, folding) => {
+	if (Predicate.isString(folding.line.id)) byId.delete(folding.line.id);
+	for (const children of folding.children.values()) for (const child of children) forget(byId, child);
+};
+const placeAt = (node, path, edges) => {
+	const [key, ...rest] = path;
+	if (key === void 0) return node;
+	if (rest.length === 0) return {
+		...node,
+		[key]: edges
+	};
+	const inner = node[key];
+	return isJsonObject(inner) ? {
+		...node,
+		[key]: placeAt(inner, rest, edges)
+	} : node;
+};
+const materialise = (folding) => {
+	let node = Object.fromEntries(Object.entries(folding.line).filter(([field]) => field !== "__parentId"));
+	for (const [key, children] of folding.children) node = placeAt(node, folding.position.connections[key]?.path ?? [key], { edges: children.map((child) => ({ node: materialise(child) })) });
+	return node;
+};
+const remember = (fold, folding) => {
+	if (holdsConnections(folding.position) && Predicate.isString(folding.line.id)) fold.byId.set(folding.line.id, folding);
+};
+const releaseCurrent = (fold) => {
+	const { current } = fold;
+	if (current === void 0) return [];
+	if (mayContinueLater(current)) {
+		fold.held.push(current);
+		return [];
+	}
+	forget(fold.byId, current);
+	return [materialise(current)];
+};
+const bulkNodes = (query) => (text) => text.pipe(Stream.mapError((cause) => new BulkResultFailed({
+	cause: withoutRequest(cause),
+	operation: query.name
+})), Stream.mapAccumEffect(() => ({
+	byId: /* @__PURE__ */ new Map(),
+	current: void 0,
+	held: []
+}), (fold, raw) => Effect.gen(function* foldLine() {
+	const line = yield* decodeObject(raw);
+	const parentId = parentIdOf(line);
+	if (parentId === void 0) {
+		const released = releaseCurrent(fold);
+		fold.current = startFolding(line, query);
+		remember(fold, fold.current);
+		return [fold, released];
+	}
+	const parent = fold.byId.get(parentId);
+	const connection = parent && connectionFor(parent.position, line.__typename);
+	if (parent === void 0 || connection === void 0) return yield* Effect.fail(releasedEarly(parentId, line.__typename));
+	const [key, position] = connection;
+	const child = startFolding(line, position);
+	parent.children.get(key)?.push(child);
+	remember(fold, child);
+	return [fold, []];
+}).pipe(Effect.mapError((cause) => new BulkResultFailed({
+	cause,
+	operation: query.name
+}))), { onHalt: (fold) => [...fold.held, ...fold.current === void 0 ? [] : [fold.current]].map(materialise) }), Stream.mapEffect((node) => Schema.decodeEffect(query.node)(node).pipe(Effect.mapError((cause) => new BulkResultFailed({
+	cause,
+	operation: query.name
+})))));
+const ResultError = Schema.Struct({ message: Schema.String });
+const UnreachedLine = Schema.fromJsonString(Schema.Struct({
+	__lineNumber: Schema.optionalKey(Schema.Int),
+	data: Schema.Record(Schema.String, Schema.NullOr(Schema.Struct({ userErrors: Schema.Array(ResultError) })))
+}));
+const unreached = (text) => Schema.decodeEffect(UnreachedLine)(text).pipe(Effect.map(({ __lineNumber, data }) => ({
+	__lineNumber,
+	errors: Object.values(data).flatMap((payload) => payload?.userErrors ?? [])
+})), Effect.filterOrFail(({ errors }) => errors.length > 0));
+const bulkResults = (name, data) => (text) => {
+	const decodeLine = Schema.decodeUnknownEffect(Schema.fromJsonString(Schema.Struct({
+		__lineNumber: Schema.optionalKey(Schema.Int),
+		data: Schema.optionalKey(Schema.NullOr(data)),
+		errors: Schema.optionalKey(Schema.Array(ResultError))
+	})));
+	return text.pipe(Stream.mapError((cause) => new BulkResultFailed({
+		cause: withoutRequest(cause),
+		operation: name
+	})), Stream.mapEffect((line) => decodeLine(line).pipe(Effect.catch((error) => unreached(line).pipe(Effect.mapError(() => error))), Effect.mapError((cause) => new BulkResultFailed({
+		cause,
+		operation: name
+	})))));
+};
+//#endregion
+export { bulkLines, bulkNodes, bulkResults, resultText };

package/dist/bulk/bulk-transport.d.mts

@@ -0,0 +1,33 @@
+import "../admin-bulk-query-registry.mjs";
+import { AdminBulkQueries, AdminBulkQueryDocument } from "../operations.mjs";
+import { AdminError } from "../admin-api.mjs";
+import "./bulk-operation-refused.mjs";
+import { BulkResultFailed } from "./bulk-result-failed.mjs";
+import * as Schema from "effect/Schema";
+import * as Effect from "effect/Effect";
+import { HttpClient } from "effect/http";
+import * as Stream from "effect/Stream";
+import { ShopDomain } from "@unisian/shopify-sessions";
+//#region src/bulk/bulk-transport.d.ts
+export declare const BulkOperation: Schema.Struct<{
+  readonly completedAt: Schema.NullOr<Schema.String>;
+  readonly createdAt: Schema.String;
+  readonly errorCode: Schema.NullOr<Schema.Union<readonly [Schema.StringForLiteralAutocomplete, Schema.Literals<readonly ["ACCESS_DENIED", "INTERNAL_SERVER_ERROR", "TIMEOUT"]>]>>;
+  readonly id: Schema.String;
+  readonly objectCount: Schema.FiniteFromString;
+  readonly partialDataUrl: Schema.NullOr<Schema.String>;
+  readonly status: Schema.Union<readonly [Schema.StringForLiteralAutocomplete, Schema.Literals<readonly ["CANCELED", "CANCELING", "COMPLETED", "CREATED", "EXPIRED", "FAILED", "RUNNING"]>]>;
+  readonly type: Schema.Union<readonly [Schema.StringForLiteralAutocomplete, Schema.Literals<readonly ["MUTATION", "QUERY"]>]>;
+  readonly url: Schema.NullOr<Schema.String>;
+}>;
+export type BulkOperation = typeof BulkOperation.Type;
+export interface BulkQueryOptions {
+  readonly groupObjects?: boolean;
+}
+export type BulkQueryArgs<Q extends AdminBulkQueryDocument> = {} extends AdminBulkQueries[Q]["parameters"] ? [parameters?: AdminBulkQueries[Q]["parameters"], options?: BulkQueryOptions] : [parameters: AdminBulkQueries[Q]["parameters"], options?: BulkQueryOptions];
+export interface BulkReads {
+  readonly operation: (id: string) => Effect.Effect<BulkOperation | null, AdminError>;
+  readonly lines: <const Q extends AdminBulkQueryDocument>(document: Q, url: string | null) => Stream.Stream<AdminBulkQueries[Q]["line"], BulkResultFailed>;
+  readonly nodes: <const Q extends AdminBulkQueryDocument>(document: Q, url: string | null) => Stream.Stream<AdminBulkQueries[Q]["node"], BulkResultFailed>;
+}
+//#endregion

package/dist/bulk/bulk-transport.mjs

@@ -0,0 +1,118 @@
+import { AdminQueryFailed } from "../admin-query-failed.mjs";
+import { sendForShop, sendForToken } from "../admin-api.mjs";
+import { AdminBulkQueryRegistry } from "../admin-bulk-query-registry.mjs";
+import { BulkOperationRefused } from "./bulk-operation-refused.mjs";
+import { bulkLines, bulkNodes, resultText } from "./bulk-results.mjs";
+import * as Schema from "effect/Schema";
+import * as Effect from "effect/Effect";
+import { HttpClient } from "effect/http";
+import { withoutRequest } from "@unisian/shopify-auth";
+import * as Stream from "effect/Stream";
+import * as Predicate from "effect/Predicate";
+//#region src/bulk/bulk-transport.ts
+const shopifyEnum = (values) => Schema.Union([Schema.StringForLiteralAutocomplete, Schema.Literals(values)]);
+const BulkOperation = Schema.Struct({
+	completedAt: Schema.NullOr(Schema.String),
+	createdAt: Schema.String,
+	errorCode: Schema.NullOr(shopifyEnum([
+		"ACCESS_DENIED",
+		"INTERNAL_SERVER_ERROR",
+		"TIMEOUT"
+	])),
+	id: Schema.String,
+	objectCount: Schema.FiniteFromString,
+	partialDataUrl: Schema.NullOr(Schema.String),
+	status: shopifyEnum([
+		"CANCELED",
+		"CANCELING",
+		"COMPLETED",
+		"CREATED",
+		"EXPIRED",
+		"FAILED",
+		"RUNNING"
+	]),
+	type: shopifyEnum(["MUTATION", "QUERY"]),
+	url: Schema.NullOr(Schema.String)
+});
+const bulkOperationFields = "id type status errorCode objectCount url partialDataUrl createdAt completedAt";
+const UserErrors = Schema.Array(Schema.Struct({
+	code: Schema.NullOr(Schema.String),
+	field: Schema.NullOr(Schema.Array(Schema.String)),
+	message: Schema.String
+}));
+const Submitted = Schema.NullOr(Schema.Struct({
+	bulkOperation: Schema.NullOr(BulkOperation),
+	userErrors: UserErrors
+}));
+const RunQuery = {
+	data: Schema.Struct({ bulkOperationRunQuery: Submitted }),
+	document: `mutation UnisianBulkRunQuery($query: String!, $groupObjects: Boolean!) { bulkOperationRunQuery(query: $query, groupObjects: $groupObjects) { bulkOperation { ${bulkOperationFields} } userErrors { code field message } } }`,
+	kind: "mutation",
+	name: "UnisianBulkRunQuery",
+	variables: Schema.Struct({
+		groupObjects: Schema.Boolean,
+		query: Schema.String
+	})
+};
+const ReadOperation = {
+	data: Schema.Struct({ bulkOperation: Schema.NullOr(BulkOperation) }),
+	document: `query UnisianBulkOperation($id: ID!) { bulkOperation(id: $id) { ${bulkOperationFields} } }`,
+	kind: "query",
+	name: "UnisianBulkOperation",
+	variables: Schema.Struct({ id: Schema.String })
+};
+const enumValue = /^[_A-Za-z][_0-9A-Za-z]*$/u;
+const EncodedParameters = Schema.Record(Schema.String, Schema.Json);
+const isJsonList = Schema.is(Schema.Array(Schema.Json));
+const literal = (value, bare) => {
+	if (isJsonList(value)) return `[${value.map((item) => literal(item, bare)).join(", ")}]`;
+	return bare && Predicate.isString(value) && enumValue.test(value) ? value : JSON.stringify(value ?? null);
+};
+const bulkQueryFor = (registry, document) => {
+	const query = registry[document];
+	return query ? Effect.succeed(query) : Effect.die(`No generated bulk query for this #graphql template; run pnpm codegen`);
+};
+const reads = ({ send, client, bulkQueries }) => ({
+	lines: (document, url) => {
+		return bulkQueryFor(bulkQueries, document).pipe(Effect.map((query) => resultText(client, url).pipe(bulkLines(query))), Stream.unwrap);
+	},
+	nodes: (document, url) => {
+		return bulkQueryFor(bulkQueries, document).pipe(Effect.map((query) => resultText(client, url).pipe(bulkNodes(query))), Stream.unwrap);
+	},
+	operation: (id) => send(ReadOperation, { id }).pipe(Effect.map(({ bulkOperation }) => bulkOperation))
+});
+const submitted = (operation, shop) => (payload) => payload?.bulkOperation && payload.userErrors.length === 0 ? Effect.succeed(payload.bulkOperation) : Effect.fail(new BulkOperationRefused({
+	operation,
+	shop,
+	userErrors: payload?.userErrors ?? []
+}));
+const renderBulkQuery = (query, parameters, shop) => Schema.encodeUnknownEffect(query.parameters)(parameters ?? {}).pipe(Effect.flatMap(Schema.decodeUnknownEffect(EncodedParameters)), Effect.map((encoded) => query.document.map((part, index) => {
+	const slot = query.slots[index];
+	return slot === void 0 ? part : `${part}${literal(encoded[slot], query.enums.includes(slot))}`;
+}).join("")), Effect.mapError((cause) => new AdminQueryFailed({
+	cause: withoutRequest(cause),
+	operation: query.name,
+	shop
+})));
+const submitQuery = ({ send, shop, bulkQueries }, guard) => (document, ...[parameters, options]) => bulkQueryFor(bulkQueries, document).pipe(Effect.tap((query) => Effect.annotateCurrentSpan("operation", query.name)), Effect.flatMap(guard), Effect.flatMap((query) => renderBulkQuery(query, parameters, shop)), Effect.flatMap((rendered) => send(RunQuery, {
+	groupObjects: options?.groupObjects ?? false,
+	query: rendered
+})), Effect.flatMap(({ bulkOperationRunQuery }) => submitted("bulkOperationRunQuery", shop)(bulkOperationRunQuery)), Effect.withSpan("ShopifyBulk.query"));
+const transportForShop = (shop) => Effect.gen(function* transportForShopGen() {
+	return {
+		bulkQueries: yield* AdminBulkQueryRegistry,
+		client: yield* HttpClient.HttpClient,
+		send: yield* sendForShop(shop),
+		shop
+	};
+});
+const transportForToken = (credential, apiVersion) => Effect.gen(function* transportForTokenGen() {
+	return {
+		bulkQueries: yield* AdminBulkQueryRegistry,
+		client: yield* HttpClient.HttpClient,
+		send: yield* sendForToken(credential, apiVersion),
+		shop: credential.shop
+	};
+});
+//#endregion
+export { BulkOperation, Submitted, bulkOperationFields, reads, submitQuery, submitted, transportForShop, transportForToken };