@unisian/shopify-admin 0.0.0 → 0.6.0

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

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

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

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

package/dist/bulk/read-only-shopify-bulk.d.mts

@@ -0,0 +1,26 @@
+import { AdminBulkQueryRegistry } from "../admin-bulk-query-registry.mjs";
+import { AdminBulkQueryDocument } from "../operations.mjs";
+import { AdminCredential, AdminError } from "../admin-api.mjs";
+import { BulkOperationRefused } from "./bulk-operation-refused.mjs";
+import { BulkOperation, BulkQueryArgs, BulkReads } from "./bulk-transport.mjs";
+import { MutationRefused } from "../mutation-refused.mjs";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import { ShopDomain } from "@unisian/shopify-sessions";
+//#region src/bulk/read-only-shopify-bulk.d.ts
+declare const ReadOnlyShopifyBulk_base: Context.ServiceClass<ReadOnlyShopifyBulk, "@unisian/shopify-admin/ReadOnlyShopifyBulk", BulkReads & {
+  readonly query: <const Q extends AdminBulkQueryDocument>(document: Q, ...args: BulkQueryArgs<Q>) => Effect.Effect<BulkOperation, AdminError | BulkOperationRefused | MutationRefused>;
+}>;
+export declare class ReadOnlyShopifyBulk extends ReadOnlyShopifyBulk_base {
+  private static readonly over;
+  static readonly makeForShop: (shop: ShopDomain) => Effect.Effect<BulkReads & {
+    readonly query: <const Q extends AdminBulkQueryDocument>(document: Q, ...args: BulkQueryArgs<Q>) => Effect.Effect<BulkOperation, AdminError | BulkOperationRefused | MutationRefused>;
+  }, never, AdminBulkQueryRegistry | import("effect/http/HttpClient").HttpClient | import("@unisian/shopify-auth").SessionOwner | import("@unisian/shopify-auth").ShopifyApp>;
+  static readonly layerForShop: (shop: ShopDomain) => Layer.Layer<ReadOnlyShopifyBulk, never, AdminBulkQueryRegistry | import("effect/http/HttpClient").HttpClient | import("@unisian/shopify-auth").SessionOwner | import("@unisian/shopify-auth").ShopifyApp>;
+  static readonly makeForToken: (credential: AdminCredential, apiVersion: string) => Effect.Effect<BulkReads & {
+    readonly query: <const Q extends AdminBulkQueryDocument>(document: Q, ...args: BulkQueryArgs<Q>) => Effect.Effect<BulkOperation, AdminError | BulkOperationRefused | MutationRefused>;
+  }, never, AdminBulkQueryRegistry | import("effect/http/HttpClient").HttpClient>;
+  static readonly layerForToken: (credential: AdminCredential, apiVersion: string) => Layer.Layer<ReadOnlyShopifyBulk, never, AdminBulkQueryRegistry | import("effect/http/HttpClient").HttpClient>;
+}
+//#endregion

package/dist/bulk/read-only-shopify-bulk.mjs

@@ -0,0 +1,23 @@
+import { MutationRefused } from "../mutation-refused.mjs";
+import { holdsMutation } from "../read-only-admin.mjs";
+import { reads, submitQuery, transportForShop, transportForToken } from "./bulk-transport.mjs";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+//#region src/bulk/read-only-shopify-bulk.ts
+const refuseMutation = (shop) => (query) => holdsMutation(query.document.join("")) ? Effect.fail(new MutationRefused({
+	operation: "bulkOperationRunQuery",
+	shop
+})) : Effect.succeed(query);
+var ReadOnlyShopifyBulk = class ReadOnlyShopifyBulk extends Context.Service()("@unisian/shopify-admin/ReadOnlyShopifyBulk") {
+	static over = (transport) => ReadOnlyShopifyBulk.of({
+		...reads(transport),
+		query: submitQuery(transport, refuseMutation(transport.shop))
+	});
+	static makeForShop = (shop) => transportForShop(shop).pipe(Effect.map(ReadOnlyShopifyBulk.over));
+	static layerForShop = (shop) => Layer.effect(ReadOnlyShopifyBulk, ReadOnlyShopifyBulk.makeForShop(shop));
+	static makeForToken = (credential, apiVersion) => transportForToken(credential, apiVersion).pipe(Effect.map(ReadOnlyShopifyBulk.over));
+	static layerForToken = (credential, apiVersion) => Layer.effect(ReadOnlyShopifyBulk, ReadOnlyShopifyBulk.makeForToken(credential, apiVersion));
+};
+//#endregion
+export { ReadOnlyShopifyBulk };

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

@@ -0,0 +1,47 @@
+import { AdminBulkQueryRegistry } from "../admin-bulk-query-registry.mjs";
+import { AdminOperationRegistry } from "../admin-operation-registry.mjs";
+import { AdminBulkQueryDocument, AdminMutationDocument, AdminOperations } from "../operations.mjs";
+import { AdminCredential, AdminError } from "../admin-api.mjs";
+import { BulkOperationRefused } from "./bulk-operation-refused.mjs";
+import { BulkResultFailed } from "./bulk-result-failed.mjs";
+import { BulkOperation, BulkQueryArgs, BulkReads } from "./bulk-transport.mjs";
+import { BulkUploadFailed } from "./bulk-upload-failed.mjs";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Stream from "effect/Stream";
+import { ShopDomain } from "@unisian/shopify-sessions";
+//#region src/bulk/shopify-bulk.d.ts
+export interface BulkResultLine<Data> {
+  readonly __lineNumber?: number;
+  readonly data?: Data | null;
+  readonly errors?: readonly {
+    readonly message: string;
+  }[];
+}
+declare const ShopifyBulk_base: Context.ServiceClass<ShopifyBulk, "@unisian/shopify-admin/ShopifyBulk", BulkReads & {
+  readonly query: <const Q extends AdminBulkQueryDocument>(document: Q, ...args: BulkQueryArgs<Q>) => Effect.Effect<BulkOperation, AdminError | BulkOperationRefused>;
+  readonly mutation: <const M extends AdminMutationDocument>(document: M, variables: Iterable<AdminOperations[M]["variables"]>) => Effect.Effect<BulkOperation, AdminError | BulkOperationRefused | BulkUploadFailed>;
+  readonly stage: <const M extends AdminMutationDocument>(document: M, variables: Iterable<AdminOperations[M]["variables"]>) => Effect.Effect<string, AdminError | BulkOperationRefused | BulkUploadFailed>;
+  readonly runMutation: (document: AdminMutationDocument, stagedUploadPath: string) => Effect.Effect<BulkOperation, AdminError | BulkOperationRefused>;
+  readonly results: <const M extends AdminMutationDocument>(document: M, url: string | null) => Stream.Stream<BulkResultLine<AdminOperations[M]["data"]>, BulkResultFailed>;
+}>;
+export declare class ShopifyBulk extends ShopifyBulk_base {
+  static readonly makeForShop: (shop: ShopDomain) => Effect.Effect<BulkReads & {
+    readonly query: <const Q extends AdminBulkQueryDocument>(document: Q, ...args: BulkQueryArgs<Q>) => Effect.Effect<BulkOperation, AdminError | BulkOperationRefused>;
+    readonly mutation: <const M extends AdminMutationDocument>(document: M, variables: Iterable<AdminOperations[M]["variables"]>) => Effect.Effect<BulkOperation, AdminError | BulkOperationRefused | BulkUploadFailed>;
+    readonly stage: <const M extends AdminMutationDocument>(document: M, variables: Iterable<AdminOperations[M]["variables"]>) => Effect.Effect<string, AdminError | BulkOperationRefused | BulkUploadFailed>;
+    readonly runMutation: (document: AdminMutationDocument, stagedUploadPath: string) => Effect.Effect<BulkOperation, AdminError | BulkOperationRefused>;
+    readonly results: <const M extends AdminMutationDocument>(document: M, url: string | null) => Stream.Stream<BulkResultLine<AdminOperations[M]["data"]>, BulkResultFailed>;
+  }, never, AdminBulkQueryRegistry | AdminOperationRegistry | import("effect/http/HttpClient").HttpClient | import("@unisian/shopify-auth").SessionOwner | import("@unisian/shopify-auth").ShopifyApp>;
+  static readonly layerForShop: (shop: ShopDomain) => Layer.Layer<ShopifyBulk, never, AdminBulkQueryRegistry | AdminOperationRegistry | import("effect/http/HttpClient").HttpClient | import("@unisian/shopify-auth").SessionOwner | import("@unisian/shopify-auth").ShopifyApp>;
+  static readonly makeForToken: (credential: AdminCredential, apiVersion: string) => Effect.Effect<BulkReads & {
+    readonly query: <const Q extends AdminBulkQueryDocument>(document: Q, ...args: BulkQueryArgs<Q>) => Effect.Effect<BulkOperation, AdminError | BulkOperationRefused>;
+    readonly mutation: <const M extends AdminMutationDocument>(document: M, variables: Iterable<AdminOperations[M]["variables"]>) => Effect.Effect<BulkOperation, AdminError | BulkOperationRefused | BulkUploadFailed>;
+    readonly stage: <const M extends AdminMutationDocument>(document: M, variables: Iterable<AdminOperations[M]["variables"]>) => Effect.Effect<string, AdminError | BulkOperationRefused | BulkUploadFailed>;
+    readonly runMutation: (document: AdminMutationDocument, stagedUploadPath: string) => Effect.Effect<BulkOperation, AdminError | BulkOperationRefused>;
+    readonly results: <const M extends AdminMutationDocument>(document: M, url: string | null) => Stream.Stream<BulkResultLine<AdminOperations[M]["data"]>, BulkResultFailed>;
+  }, never, AdminBulkQueryRegistry | AdminOperationRegistry | import("effect/http/HttpClient").HttpClient>;
+  static readonly layerForToken: (credential: AdminCredential, apiVersion: string) => Layer.Layer<ShopifyBulk, never, AdminBulkQueryRegistry | AdminOperationRegistry | import("effect/http/HttpClient").HttpClient>;
+}
+//#endregion

package/dist/bulk/shopify-bulk.mjs

@@ -0,0 +1,123 @@
+import { AdminOperationRegistry } from "../admin-operation-registry.mjs";
+import { BulkOperationRefused } from "./bulk-operation-refused.mjs";
+import { bulkResults, resultText } from "./bulk-results.mjs";
+import { Submitted, bulkOperationFields, reads, submitQuery, submitted, transportForShop, transportForToken } from "./bulk-transport.mjs";
+import { BulkUploadFailed } from "./bulk-upload-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 { HttpClientRequest, HttpClientResponse } from "effect/http";
+import { withoutRequest } from "@unisian/shopify-auth";
+import { operationFor } from "@unisian/shopify-auth/kernel";
+import * as Stream from "effect/Stream";
+//#region src/bulk/shopify-bulk.ts
+const RunMutation = {
+	data: Schema.Struct({ bulkOperationRunMutation: Submitted }),
+	document: `mutation UnisianBulkRunMutation($mutation: String!, $stagedUploadPath: String!) { bulkOperationRunMutation(mutation: $mutation, stagedUploadPath: $stagedUploadPath) { bulkOperation { ${bulkOperationFields} } userErrors { code field message } } }`,
+	kind: "mutation",
+	name: "UnisianBulkRunMutation",
+	variables: Schema.Struct({
+		mutation: Schema.String,
+		stagedUploadPath: Schema.String
+	})
+};
+const StagedUpload = {
+	data: Schema.Struct({ stagedUploadsCreate: Schema.NullOr(Schema.Struct({
+		stagedTargets: Schema.NullOr(Schema.Array(Schema.Struct({
+			parameters: Schema.Array(Schema.Struct({
+				name: Schema.String,
+				value: Schema.String
+			})),
+			url: Schema.NullOr(Schema.String)
+		}))),
+		userErrors: Schema.Array(Schema.Struct({
+			field: Schema.NullOr(Schema.Array(Schema.String)),
+			message: Schema.String
+		}))
+	})) }),
+	document: "mutation UnisianBulkStagedUpload($filename: String!) { stagedUploadsCreate(input: [{ resource: BULK_MUTATION_VARIABLES, filename: $filename, mimeType: \"text/jsonl\", httpMethod: POST }]) { stagedTargets { url parameters { name value } } userErrors { field message } } }",
+	kind: "mutation",
+	name: "UnisianBulkStagedUpload",
+	variables: Schema.Struct({ filename: Schema.String })
+};
+const jsonlLimitBytes = 1e8;
+const upload = ({ send, shop, client }, operation, jsonl) => Effect.gen(function* uploadGen() {
+	const uploadFailed = (cause) => new BulkUploadFailed({
+		cause: withoutRequest(cause),
+		operation,
+		shop
+	});
+	const filename = `${operation}.jsonl`;
+	const { stagedUploadsCreate } = yield* send(StagedUpload, { filename });
+	const userErrors = stagedUploadsCreate?.userErrors ?? [];
+	if (userErrors.length > 0) return yield* new BulkOperationRefused({
+		operation: "stagedUploadsCreate",
+		shop,
+		userErrors: userErrors.map((error) => ({
+			...error,
+			code: null
+		}))
+	});
+	const target = stagedUploadsCreate?.stagedTargets?.[0];
+	const url = target?.url ?? null;
+	const key = target?.parameters.find((parameter) => parameter.name === "key")?.value;
+	if (target === void 0 || url === null || key === void 0) return yield* uploadFailed("stagedUploadsCreate returned no target with a key");
+	const form = new FormData();
+	for (const parameter of target.parameters) form.append(parameter.name, parameter.value);
+	form.append("file", new Blob([jsonl], { type: "text/jsonl" }), filename);
+	yield* client.execute(HttpClientRequest.post(url).pipe(HttpClientRequest.bodyFormData(form))).pipe(Effect.flatMap(HttpClientResponse.filterStatusOk), Effect.mapError(uploadFailed));
+	return key;
+});
+const fullBulk = (transport, registry) => {
+	const { send, shop, client } = transport;
+	const mutationFor = (document) => operationFor(registry, document).pipe(Effect.filterOrElse((operation) => operation.kind === "mutation", (operation) => Effect.die(`${operation.name} is a query; a bulk mutation runs a mutation`)));
+	const stage = Effect.fn("ShopifyBulk.stage")(function* stageGen(document, variables) {
+		const operation = yield* mutationFor(document);
+		yield* Effect.annotateCurrentSpan("operation", operation.name);
+		const uploadFailed = (cause) => new BulkUploadFailed({
+			cause: withoutRequest(cause),
+			operation: operation.name,
+			shop
+		});
+		const lines = yield* Effect.forEach(variables, (line) => Schema.encodeUnknownEffect(operation.variables)(line).pipe(Effect.map((encoded) => `${JSON.stringify(encoded)}\n`), Effect.mapError(uploadFailed)));
+		const jsonl = new TextEncoder().encode(lines.join(""));
+		if (jsonl.byteLength > jsonlLimitBytes) return yield* uploadFailed(`the JSONL is ${jsonl.byteLength} bytes; Shopify takes ${jsonlLimitBytes} at most`);
+		return yield* upload(transport, operation.name, jsonl);
+	});
+	const runMutation = Effect.fn("ShopifyBulk.runMutation")(function* runMutationGen(document, stagedUploadPath) {
+		const operation = yield* mutationFor(document);
+		yield* Effect.annotateCurrentSpan("operation", operation.name);
+		const { bulkOperationRunMutation } = yield* send(RunMutation, {
+			mutation: operation.document,
+			stagedUploadPath
+		});
+		return yield* submitted("bulkOperationRunMutation", shop)(bulkOperationRunMutation);
+	});
+	const mutation = (document, variables) => stage(document, variables).pipe(Effect.flatMap((stagedUploadPath) => runMutation(document, stagedUploadPath)), Effect.withSpan("ShopifyBulk.mutation"));
+	const results = (document, url) => {
+		return mutationFor(document).pipe(Effect.map((operation) => resultText(client, url).pipe(bulkResults(operation.name, operation.data))), Stream.unwrap);
+	};
+	return {
+		...reads(transport),
+		mutation,
+		query: submitQuery(transport, Effect.succeed),
+		results,
+		runMutation,
+		stage
+	};
+};
+var ShopifyBulk = class ShopifyBulk extends Context.Service()("@unisian/shopify-admin/ShopifyBulk") {
+	static makeForShop = (shop) => Effect.gen(function* makeForShop() {
+		const registry = yield* AdminOperationRegistry;
+		return ShopifyBulk.of(fullBulk(yield* transportForShop(shop), registry));
+	});
+	static layerForShop = (shop) => Layer.effect(ShopifyBulk, ShopifyBulk.makeForShop(shop));
+	static makeForToken = (credential, apiVersion) => Effect.gen(function* makeForToken() {
+		const registry = yield* AdminOperationRegistry;
+		return ShopifyBulk.of(fullBulk(yield* transportForToken(credential, apiVersion), registry));
+	});
+	static layerForToken = (credential, apiVersion) => Layer.effect(ShopifyBulk, ShopifyBulk.makeForToken(credential, apiVersion));
+};
+//#endregion
+export { ShopifyBulk };

package/dist/bulk.d.mts

@@ -0,0 +1,8 @@
+import { BulkOperationRefused } from "./bulk/bulk-operation-refused.mjs";
+import { BulkResultFailed } from "./bulk/bulk-result-failed.mjs";
+import { BulkOperation, BulkQueryArgs, BulkQueryOptions } from "./bulk/bulk-transport.mjs";
+import { BulkUploadFailed } from "./bulk/bulk-upload-failed.mjs";
+import { BulkResultLine, ShopifyBulk } from "./bulk/shopify-bulk.mjs";
+import { ReadOnlyShopifyBulk } from "./bulk/read-only-shopify-bulk.mjs";
+import { BULK_OPERATIONS_FINISH_TOPIC, BulkOperationsFinish } from "./bulk/bulk-operations-finish.mjs";
+export { BULK_OPERATIONS_FINISH_TOPIC, type BulkOperation, BulkOperationRefused, BulkOperationsFinish, type BulkQueryArgs, type BulkQueryOptions, BulkResultFailed, type BulkResultLine, BulkUploadFailed, ReadOnlyShopifyBulk, ShopifyBulk };

package/dist/bulk.mjs

@@ -0,0 +1,7 @@
+import { BulkOperationRefused } from "./bulk/bulk-operation-refused.mjs";
+import { BulkResultFailed } from "./bulk/bulk-result-failed.mjs";
+import { BulkUploadFailed } from "./bulk/bulk-upload-failed.mjs";
+import { ShopifyBulk } from "./bulk/shopify-bulk.mjs";
+import { ReadOnlyShopifyBulk } from "./bulk/read-only-shopify-bulk.mjs";
+import { BULK_OPERATIONS_FINISH_TOPIC, BulkOperationsFinish } from "./bulk/bulk-operations-finish.mjs";
+export { BULK_OPERATIONS_FINISH_TOPIC, BulkOperationRefused, BulkOperationsFinish, BulkResultFailed, BulkUploadFailed, ReadOnlyShopifyBulk, ShopifyBulk };

package/dist/delegate-token-refused.d.mts

@@ -0,0 +1,10 @@
+import * as Schema from "effect/Schema";
+//#region src/delegate-token-refused.d.ts
+declare const DelegateTokenRefused_base: Schema.Class<DelegateTokenRefused, Schema.TaggedStruct<"DelegateTokenRefused", {
+  readonly codes: Schema.$Array<Schema.NullOr<Schema.String>>;
+  readonly shop: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class DelegateTokenRefused extends DelegateTokenRefused_base {
+  get message(): string;
+}
+//#endregion

package/dist/delegate-token-refused.mjs

@@ -0,0 +1,12 @@
+import * as Schema from "effect/Schema";
+//#region src/delegate-token-refused.ts
+var DelegateTokenRefused = class extends Schema.TaggedError()("DelegateTokenRefused", {
+	codes: Schema.Array(Schema.NullOr(Schema.String)),
+	shop: Schema.String
+}) {
+	get message() {
+		return `Shopify refused a delegate token for ${this.shop} (${this.codes.join(", ")})`;
+	}
+};
+//#endregion
+export { DelegateTokenRefused };

package/dist/delegate-token.d.mts

@@ -0,0 +1,17 @@
+import { AccessTokenRejected } from "./access-token-rejected.mjs";
+import { AdminQueryFailed } from "./admin-query-failed.mjs";
+import { AdminCredential } from "./admin-api.mjs";
+import { DelegateTokenRefused } from "./delegate-token-refused.mjs";
+import * as Schema from "effect/Schema";
+import * as Effect from "effect/Effect";
+//#region src/delegate-token.d.ts
+declare const DelegateToken_base: Schema.Class<DelegateToken, Schema.Struct<{
+  readonly accessToken: Schema.Redacted<Schema.String>;
+  readonly expiresAt: Schema.Int;
+}>, {}>;
+export declare class DelegateToken extends DelegateToken_base {}
+export declare const createDelegateToken: (apiVersion: string, parent: AdminCredential, delegate: {
+  readonly scopes: readonly string[];
+  readonly expiresInSeconds: number;
+}) => Effect.Effect<DelegateToken, AccessTokenRejected | AdminQueryFailed | DelegateTokenRefused, import("effect/http/HttpClient").HttpClient>;
+//#endregion

package/dist/delegate-token.mjs

@@ -0,0 +1,45 @@
+import { sendAdminDocument } from "./admin-api.mjs";
+import { DelegateTokenRefused } from "./delegate-token-refused.mjs";
+import * as Schema from "effect/Schema";
+import * as Effect from "effect/Effect";
+import * as Redacted from "effect/Redacted";
+import * as Clock from "effect/Clock";
+//#region src/delegate-token.ts
+const createDelegate = `mutation DelegateAccessTokenCreate($input: DelegateAccessTokenInput!) {
+  delegateAccessTokenCreate(input: $input) {
+    delegateAccessToken { accessToken expiresIn }
+    userErrors { code message }
+  }
+}`;
+const Created = Schema.Struct({ delegateAccessTokenCreate: Schema.Struct({
+	delegateAccessToken: Schema.NullOr(Schema.Struct({
+		accessToken: Schema.String,
+		expiresIn: Schema.Int
+	})),
+	userErrors: Schema.Array(Schema.Struct({
+		code: Schema.NullOr(Schema.String),
+		message: Schema.String
+	}))
+}) });
+var DelegateToken = class extends Schema.Class("DelegateToken")({
+	accessToken: Schema.Redacted(Schema.String),
+	expiresAt: Schema.Int
+}) {};
+const createDelegateToken = Effect.fn("createDelegateToken")(function* createDelegateToken(apiVersion, parent, delegate) {
+	const result = yield* sendAdminDocument(apiVersion, parent, createDelegate, { input: {
+		delegateAccessScope: [...delegate.scopes],
+		expiresIn: delegate.expiresInSeconds
+	} });
+	const { delegateAccessTokenCreate: created } = yield* Schema.decodeUnknownEffect(Created)(result.data).pipe(Effect.orDie);
+	if (created.delegateAccessToken === null) return yield* new DelegateTokenRefused({
+		codes: created.userErrors.map((error) => error.code),
+		shop: parent.shop
+	});
+	const now = yield* Clock.currentTimeMillis;
+	return new DelegateToken({
+		accessToken: Redacted.make(created.delegateAccessToken.accessToken),
+		expiresAt: now + created.delegateAccessToken.expiresIn * 1e3
+	});
+});
+//#endregion
+export { DelegateToken, createDelegateToken };

package/dist/index.d.mts

@@ -0,0 +1,12 @@
+import { AdminBulkQuery, AdminBulkQueryRegistry, BulkConnection, BulkLines } from "./admin-bulk-query-registry.mjs";
+import { AccessTokenRejected } from "./access-token-rejected.mjs";
+import { AdminOperation, AdminOperationRegistry } from "./admin-operation-registry.mjs";
+import { AdminQueryFailed } from "./admin-query-failed.mjs";
+import { AdminBulkQueries, AdminBulkQueryDocument, AdminDocument, AdminMutationDocument, AdminOperations, AdminQueryDocument } from "./operations.mjs";
+import { AdminCredential, AdminDocumentResult, AdminError, ShopifyAdmin, sendAdminDocument } from "./admin-api.mjs";
+import { MutationRefused } from "./mutation-refused.mjs";
+import { DelegateTokenRefused } from "./delegate-token-refused.mjs";
+import { DelegateToken, createDelegateToken } from "./delegate-token.mjs";
+import { BulkOperationRunQueryData, ReadOnlyShopifyAdmin } from "./read-only-admin.mjs";
+import { ShopifyLayerConfig, shopifyLayer } from "./shopify-layer.mjs";
+export { AccessTokenRejected, type AdminBulkQueries, type AdminBulkQuery, type AdminBulkQueryDocument, AdminBulkQueryRegistry, type AdminCredential, type AdminDocument, type AdminDocumentResult, type AdminError, type AdminMutationDocument, type AdminOperation, AdminOperationRegistry, type AdminOperations, type AdminQueryDocument, AdminQueryFailed, type BulkConnection, type BulkLines, type BulkOperationRunQueryData, DelegateToken, DelegateTokenRefused, MutationRefused, ReadOnlyShopifyAdmin, ShopifyAdmin, type ShopifyLayerConfig, createDelegateToken, sendAdminDocument, shopifyLayer };

package/dist/index.mjs

@@ -0,0 +1,11 @@
+import { AccessTokenRejected } from "./access-token-rejected.mjs";
+import { AdminOperationRegistry } from "./admin-operation-registry.mjs";
+import { AdminQueryFailed } from "./admin-query-failed.mjs";
+import { ShopifyAdmin, sendAdminDocument } from "./admin-api.mjs";
+import { AdminBulkQueryRegistry } from "./admin-bulk-query-registry.mjs";
+import { DelegateTokenRefused } from "./delegate-token-refused.mjs";
+import { DelegateToken, createDelegateToken } from "./delegate-token.mjs";
+import { MutationRefused } from "./mutation-refused.mjs";
+import { ReadOnlyShopifyAdmin } from "./read-only-admin.mjs";
+import { shopifyLayer } from "./shopify-layer.mjs";
+export { AccessTokenRejected, AdminBulkQueryRegistry, AdminOperationRegistry, AdminQueryFailed, DelegateToken, DelegateTokenRefused, MutationRefused, ReadOnlyShopifyAdmin, ShopifyAdmin, createDelegateToken, sendAdminDocument, shopifyLayer };

package/dist/mutation-refused.d.mts

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

package/dist/mutation-refused.mjs

@@ -0,0 +1,12 @@
+import * as Schema from "effect/Schema";
+//#region src/mutation-refused.ts
+var MutationRefused = class extends Schema.TaggedError()("MutationRefused", {
+	operation: Schema.String,
+	shop: Schema.String
+}) {
+	get message() {
+		return `The read-only Admin client refused ${this.operation} for ${this.shop}: it sends queries only`;
+	}
+};
+//#endregion
+export { MutationRefused };

package/dist/operations.d.mts

@@ -0,0 +1,12 @@
+//#region src/operations.d.ts
+export interface AdminOperations {}
+export type AdminDocument = Extract<keyof AdminOperations, string>;
+export type AdminQueryDocument = { readonly [Q in AdminDocument]: AdminOperations[Q] extends {
+  readonly kind: "query";
+} ? Q : never; }[AdminDocument];
+export type AdminMutationDocument = { readonly [Q in AdminDocument]: AdminOperations[Q] extends {
+  readonly kind: "mutation";
+} ? Q : never; }[AdminDocument];
+export interface AdminBulkQueries {}
+export type AdminBulkQueryDocument = Extract<keyof AdminBulkQueries, string>;
+//#endregion

package/dist/operations.mjs

@@ -0,0 +1 @@
+export {};

package/dist/read-only-admin.d.mts

@@ -0,0 +1,49 @@
+import { AdminOperationRegistry } from "./admin-operation-registry.mjs";
+import { AdminOperations, AdminQueryDocument } from "./operations.mjs";
+import { AdminCredential, AdminError, VariablesArgs } from "./admin-api.mjs";
+import { MutationRefused } from "./mutation-refused.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 { ShopDomain } from "@unisian/shopify-sessions";
+//#region src/read-only-admin.d.ts
+declare const BulkOperationRunQuery: {
+  data: Schema.Struct<{
+    readonly bulkOperationRunQuery: Schema.NullOr<Schema.Struct<{
+      readonly bulkOperation: Schema.NullOr<Schema.Struct<{
+        readonly id: Schema.String;
+        readonly status: Schema.String;
+      }>>;
+      readonly userErrors: Schema.$Array<Schema.Struct<{
+        readonly field: Schema.NullOr<Schema.$Array<Schema.String>>;
+        readonly message: Schema.String;
+      }>>;
+    }>>;
+  }>;
+  document: string;
+  kind: "mutation";
+  name: string;
+  variables: Schema.Struct<{
+    readonly query: Schema.String;
+  }>;
+};
+export type BulkOperationRunQueryData = typeof BulkOperationRunQuery.data.Type;
+declare const ReadOnlyShopifyAdmin_base: Context.ServiceClass<ReadOnlyShopifyAdmin, "@unisian/shopify-admin/ReadOnlyShopifyAdmin", {
+  readonly graphql: <const Q extends AdminQueryDocument>(document: Q, ...variables: VariablesArgs<Q>) => Effect.Effect<AdminOperations[Q]["data"], AdminError>;
+  readonly bulkOperationRunQuery: (query: string) => Effect.Effect<BulkOperationRunQueryData, AdminError | MutationRefused>;
+}>;
+export declare class ReadOnlyShopifyAdmin extends ReadOnlyShopifyAdmin_base {
+  private static readonly over;
+  static readonly makeForShop: (shop: ShopDomain) => Effect.Effect<{
+    readonly graphql: <const Q extends AdminQueryDocument>(document: Q, ...variables: VariablesArgs<Q>) => Effect.Effect<AdminOperations[Q]["data"], AdminError>;
+    readonly bulkOperationRunQuery: (query: string) => Effect.Effect<BulkOperationRunQueryData, AdminError | MutationRefused>;
+  }, never, AdminOperationRegistry | import("effect/http/HttpClient").HttpClient | import("@unisian/shopify-auth").SessionOwner | import("@unisian/shopify-auth").ShopifyApp>;
+  static readonly layerForShop: (shop: ShopDomain) => Layer.Layer<ReadOnlyShopifyAdmin, never, AdminOperationRegistry | import("effect/http/HttpClient").HttpClient | import("@unisian/shopify-auth").SessionOwner | import("@unisian/shopify-auth").ShopifyApp>;
+  static readonly makeForToken: (credential: AdminCredential, apiVersion: string) => Effect.Effect<{
+    readonly graphql: <const Q extends AdminQueryDocument>(document: Q, ...variables: VariablesArgs<Q>) => Effect.Effect<AdminOperations[Q]["data"], AdminError>;
+    readonly bulkOperationRunQuery: (query: string) => Effect.Effect<BulkOperationRunQueryData, AdminError | MutationRefused>;
+  }, never, AdminOperationRegistry | import("effect/http/HttpClient").HttpClient>;
+  static readonly layerForToken: (credential: AdminCredential, apiVersion: string) => Layer.Layer<ReadOnlyShopifyAdmin, never, AdminOperationRegistry | import("effect/http/HttpClient").HttpClient>;
+}
+//#endregion

package/dist/read-only-admin.mjs

@@ -0,0 +1,60 @@
+import { AdminOperationRegistry } from "./admin-operation-registry.mjs";
+import { sendForShop, sendForToken } from "./admin-api.mjs";
+import { MutationRefused } from "./mutation-refused.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 { operationFor } from "@unisian/shopify-auth/kernel";
+//#region src/read-only-admin.ts
+const BulkOperationRunQuery = {
+	data: Schema.Struct({ bulkOperationRunQuery: Schema.NullOr(Schema.Struct({
+		bulkOperation: Schema.NullOr(Schema.Struct({
+			id: Schema.String,
+			status: Schema.String
+		})),
+		userErrors: Schema.Array(Schema.Struct({
+			field: Schema.NullOr(Schema.Array(Schema.String)),
+			message: Schema.String
+		}))
+	})) }),
+	document: "mutation BulkOperationRunQuery($query: String!) {\n  bulkOperationRunQuery(query: $query) {\n    bulkOperation {\n      id\n      status\n    }\n    userErrors {\n      field\n      message\n    }\n  }\n}",
+	kind: "mutation",
+	name: "BulkOperationRunQuery",
+	variables: Schema.Struct({ query: Schema.String })
+};
+const graphqlComment = /#[^\n]*/gu;
+const mutationKeyword = /(?:^|[\s{])mutation(?=[\s({#])/u;
+const holdsMutation = (document) => mutationKeyword.test(document.replaceAll(graphqlComment, ""));
+var ReadOnlyShopifyAdmin = class ReadOnlyShopifyAdmin extends Context.Service()("@unisian/shopify-admin/ReadOnlyShopifyAdmin") {
+	static over = (registry, send, shop) => {
+		const graphql = (document, ...[variables]) => {
+			return operationFor(registry, document).pipe(Effect.flatMap((operation) => operation.kind === "query" ? send(operation, variables ?? {}) : Effect.die(new MutationRefused({
+				operation: operation.name,
+				shop
+			}))));
+		};
+		const bulkOperationRunQuery = (query) => holdsMutation(query) ? Effect.fail(new MutationRefused({
+			operation: BulkOperationRunQuery.name,
+			shop
+		})) : send(BulkOperationRunQuery, { query });
+		return ReadOnlyShopifyAdmin.of({
+			bulkOperationRunQuery,
+			graphql
+		});
+	};
+	static makeForShop = (shop) => Effect.gen(function* makeForShop() {
+		const registry = yield* AdminOperationRegistry;
+		const send = yield* sendForShop(shop);
+		return ReadOnlyShopifyAdmin.over(registry, send, shop);
+	});
+	static layerForShop = (shop) => Layer.effect(ReadOnlyShopifyAdmin, ReadOnlyShopifyAdmin.makeForShop(shop));
+	static makeForToken = (credential, apiVersion) => Effect.gen(function* makeForToken() {
+		const registry = yield* AdminOperationRegistry;
+		const send = yield* sendForToken(credential, apiVersion);
+		return ReadOnlyShopifyAdmin.over(registry, send, credential.shop);
+	});
+	static layerForToken = (credential, apiVersion) => Layer.effect(ReadOnlyShopifyAdmin, ReadOnlyShopifyAdmin.makeForToken(credential, apiVersion));
+};
+//#endregion
+export { ReadOnlyShopifyAdmin, holdsMutation };

package/dist/shopify-layer.d.mts

@@ -0,0 +1,11 @@
+import { AdminOperation, AdminOperationRegistry } from "./admin-operation-registry.mjs";
+import * as Layer from "effect/Layer";
+import { ShopSessionsNamespace, ShopifyApp, ShopifyAppConfig, ShopifyAuth } from "@unisian/shopify-auth";
+//#region src/shopify-layer.d.ts
+export interface ShopifyLayerConfig {
+  readonly app: ShopifyAppConfig;
+  readonly sessions: ShopSessionsNamespace;
+  readonly operations: Readonly<Record<string, AdminOperation>>;
+}
+export declare const shopifyLayer: (config: ShopifyLayerConfig) => Layer.Layer<AdminOperationRegistry | import("effect/http/HttpClient").HttpClient | import("@unisian/shopify-auth").SessionOwner | ShopifyApp | ShopifyAuth, never, never>;
+//#endregion

package/dist/shopify-layer.mjs

@@ -0,0 +1,8 @@
+import { AdminOperationRegistry } from "./admin-operation-registry.mjs";
+import * as Layer from "effect/Layer";
+import { FetchHttpClient } from "effect/http";
+import { ShopifyApp, ShopifyAuth, shopSessionsLayer } from "@unisian/shopify-auth";
+//#region src/shopify-layer.ts
+const shopifyLayer = (config) => ShopifyAuth.layer.pipe(Layer.provideMerge(Layer.mergeAll(ShopifyApp.layer(config.app), shopSessionsLayer(config.sessions), AdminOperationRegistry.layer(config.operations), FetchHttpClient.layer)));
+//#endregion
+export { shopifyLayer };

package/dist/testing.d.mts

@@ -0,0 +1,29 @@
+import { AdminBulkQuery } from "./admin-bulk-query-registry.mjs";
+import { AdminOperation } from "./admin-operation-registry.mjs";
+import { ShopifyAdmin } from "./admin-api.mjs";
+import { ShopifyBulk } from "./bulk/shopify-bulk.mjs";
+import { ReadOnlyShopifyBulk } from "./bulk/read-only-shopify-bulk.mjs";
+import { ReadOnlyShopifyAdmin } from "./read-only-admin.mjs";
+import * as Schema from "effect/Schema";
+import * as Layer from "effect/Layer";
+import { ShopDomain } from "@unisian/shopify-sessions";
+//#region src/testing.d.ts
+export interface SentOperation {
+  readonly shop: string;
+  readonly name: string;
+  readonly variables: Schema.Json | undefined;
+}
+export type Answer = (variables: Schema.Json | undefined) => Schema.Json;
+export type FileAnswer = (request: Request) => Response | Promise<Response>;
+export interface BulkStub {
+  readonly bulkQueries?: Readonly<Record<string, AdminBulkQuery>>;
+  readonly files?: Readonly<Record<string, FileAnswer>>;
+}
+export declare const adminStub: (shop: ShopDomain, operations: Readonly<Record<string, AdminOperation>>, answers: Readonly<Record<string, Answer>>, bulk?: BulkStub) => {
+  bulkLayer: Layer.Layer<ShopifyBulk, never, never>;
+  layer: Layer.Layer<ShopifyAdmin, never, never>;
+  readOnlyBulkLayer: Layer.Layer<ReadOnlyShopifyBulk, never, never>;
+  readOnlyLayer: Layer.Layer<ReadOnlyShopifyAdmin, never, never>;
+  sent: SentOperation[];
+};
+//#endregion