@tollwyn/baukasten 0.0.2 → 1.2.2

package/dist/shopify/admin.d.ts

@@ -0,0 +1,33 @@
+import type { Log } from '../server/log.js';
+import type { ShopifyApi } from './ports.js';
+import type { Shops } from './shops.js';
+/** The shop gave no token that works: it removed the app, or only the merchant can get a new one. */
+export declare class ShopGone extends Error {
+    name: string;
+}
+/** The Admin API refused the query; the errors as Shopify named them. */
+export declare class AdminRefused extends Error {
+    name: string;
+    readonly errors: readonly {
+        message: string;
+        code: string | null;
+    }[];
+    constructor(errors: readonly {
+        message: string;
+        code: string | null;
+    }[]);
+}
+export interface AdminApi {
+    /**
+     * The data of a GraphQL query, unparsed: the app parses what it asked for. Over the shop's limit
+     * it waits and tries again a few times, then fails; ShopGone and AdminRefused name the other
+     * failures.
+     */
+    graphql(query: string, variables?: Readonly<Record<string, unknown>>): Promise<unknown>;
+}
+export declare function adminApi(shop: string, deps: {
+    api: ShopifyApi;
+    shops: Shops;
+    log: Log;
+    wait: (ms: number) => Promise<void>;
+}): AdminApi;

package/dist/shopify/admin.js

@@ -0,0 +1,47 @@
+/** Over its limit, a query waits and tries again this often before it fails. */
+const THROTTLE_TRIES = 5;
+/** The shop gave no token that works: it removed the app, or only the merchant can get a new one. */
+export class ShopGone extends Error {
+    name = 'ShopGone';
+}
+/** The Admin API refused the query; the errors as Shopify named them. */
+export class AdminRefused extends Error {
+    name = 'AdminRefused';
+    errors;
+    constructor(errors) {
+        super(`the Admin API refused the query: ${errors.map((e) => e.code ?? e.message).join(', ')}`);
+        this.errors = errors;
+    }
+}
+export function adminApi(shop, deps) {
+    return {
+        async graphql(query, variables = {}) {
+            for (let attempt = 1;; attempt += 1) {
+                const token = await deps.shops.accessToken(shop);
+                if (token === null)
+                    throw new ShopGone(`${shop} gave the app no token that works`);
+                const answer = await deps.api.graphql(shop, token, query, variables);
+                switch (answer.kind) {
+                    case 'data':
+                        return answer.data;
+                    case 'errors':
+                        throw new AdminRefused(answer.errors);
+                    case 'unauthorized':
+                        // A refresh meanwhile ended the token this query took: the next try takes the new one.
+                        if (!(await deps.shops.forgetTokens(shop, token)) && attempt < THROTTLE_TRIES)
+                            break;
+                        throw new ShopGone(`${shop} no longer takes the token of the app`);
+                    case 'throttled':
+                        if (attempt >= THROTTLE_TRIES) {
+                            throw new Error(`the Admin API of ${shop} stayed over its limit`);
+                        }
+                        deps.log.debug('shopify: over the limit of a shop, waiting', {
+                            shop,
+                            ms: answer.waitMs
+                        });
+                        await deps.wait(answer.waitMs);
+                }
+            }
+        }
+    };
+}

package/dist/shopify/app.d.ts

@@ -0,0 +1,60 @@
+import { type Language, type ProductEnv, type Role, type Transfer } from '../product.js';
+/** A plan of the app, by the handle Shopify App Pricing gives it in the Partner Dashboard. */
+export interface ShopifyPlan {
+    handle: string;
+    /** Whether it costs money: a shop on it past its trial counts as paying in the sales numbers. */
+    paid: boolean;
+}
+/**
+ * What the privacy text says of the app, in its language, and true. The sentences are whole, each
+ * ending with a full stop; the parts of a sentence have none at their end.
+ */
+export interface ShopifyPrivacy {
+    /** What the app does for the merchant, in whole sentences: the purpose of all it processes. */
+    service: string;
+    /**
+     * The personal data it processes for the merchant besides the shop of the baukasten, like the
+     * customers on the orders it reads: the merchant is their controller, the operator its processor.
+     */
+    data: readonly {
+        /** A short name, like «Customers on orders». */
+        name: string;
+        /** What they are, like «the name, address and email address on each order». */
+        what: string;
+        /** Where they come from, like «your shop at Shopify». */
+        source: string;
+        /** Why, like «to write the invoice of each order to your accounting». */
+        purpose: string;
+        /** How long, like «until the invoice is written; then only its number stays». */
+        kept: string;
+    }[];
+    /** Who gets personal data from it besides Shopify and the providers of the fleet. */
+    recipients: readonly {
+        /** Like «Pennylane SAS, your accounting». */
+        name: string;
+        /** The country, like «France». */
+        place: string;
+        transfer: Transfer;
+        /** A processor is a sub-processor of the operator, which the merchant approves. */
+        role: Role;
+        /** What it gets and why, like «gets the invoices of your orders, in your own account». */
+        purpose: string;
+    }[];
+}
+export interface ShopifyApp<E extends ProductEnv = ProductEnv> {
+    /** The privacy text and the few pages of the baukasten come in this language. */
+    language: Language;
+    env: E;
+    /** Every plan of the app, as it stands in the Partner Dashboard. */
+    plans: readonly ShopifyPlan[];
+    /**
+     * The day the app's part of its privacy text (`privacy`) last changed, as YYYY-MM-DD; the text is
+     * dated by the later of this day and that of the baukasten's part.
+     */
+    privacyDate: string;
+    privacy: ShopifyPrivacy;
+}
+/** Whether `value` is an app that defineShopifyApp accepted, such as baukasten.config.ts exports. */
+export declare function isShopifyApp(value: unknown): value is ShopifyApp;
+/** Declares the configuration of a Shopify app; anything wrong with it stops the app loudly. */
+export declare function defineShopifyApp<const E extends ProductEnv>(app: ShopifyApp<E>): ShopifyApp<E>;

package/dist/shopify/app.js

@@ -0,0 +1,67 @@
+import { z } from 'zod';
+import { LANGUAGES, ROLES, TRANSFERS } from '../product.js';
+import { BAUKASTEN_VARIABLES } from '../variables.js';
+const NAME = /^[A-Z][A-Z0-9_]*$/;
+const OWN = new Set(BAUKASTEN_VARIABLES);
+const text = z
+    .string('must not be empty')
+    .trim()
+    .min(1, { error: 'must not be empty', abort: true });
+const sentences = text.regex(/[.!?]$/, 'must be whole sentences, ending with a full stop');
+const part = text.regex(/[^.!?;:,]$/, 'must be part of a sentence, without a full stop at the end');
+const SETTINGS = z.object({
+    language: z.enum(LANGUAGES, 'must be en or de'),
+    plans: z
+        .array(z.object({
+        handle: z
+            .string()
+            .regex(/^[a-z0-9]+(?:[-_][a-z0-9]+)*$/, 'must be a handle like basic or pro-yearly'),
+        paid: z.boolean('must be true or false')
+    }))
+        .min(1, 'must name a plan')
+        .superRefine((plans, ctx) => {
+        const handles = plans.map((plan) => plan.handle);
+        for (const handle of handles.filter((h, i) => handles.indexOf(h) !== i)) {
+            ctx.addIssue({ code: 'custom', message: `names the handle ${handle} twice` });
+        }
+    }),
+    privacyDate: z.iso.date('must be a day like 2026-10-08'),
+    privacy: z.object({
+        service: sentences,
+        data: z.array(z.object({ name: part, what: part, source: part, purpose: part, kept: part })),
+        recipients: z.array(z.object({
+            name: part,
+            place: part,
+            transfer: z.enum(TRANSFERS, 'must be adequate, dpf or scc'),
+            role: z.enum(ROLES, 'must be processor or controller'),
+            purpose: part
+        }))
+    }, 'must be given')
+});
+/** What defineShopifyApp accepted; the migration command finds the app by it. */
+const DEFINED = new WeakSet();
+/** Whether `value` is an app that defineShopifyApp accepted, such as baukasten.config.ts exports. */
+export function isShopifyApp(value) {
+    return typeof value === 'object' && value !== null && DEFINED.has(value);
+}
+/** Declares the configuration of a Shopify app; anything wrong with it stops the app loudly. */
+export function defineShopifyApp(app) {
+    const names = Object.keys(app.env);
+    const problems = [];
+    const taken = names.filter((name) => OWN.has(name));
+    if (taken.length > 0) {
+        problems.push(`variables ${taken.join(', ')} ${taken.length === 1 ? 'is' : 'are'} read by the baukasten itself`);
+    }
+    const malformed = names.filter((name) => !NAME.test(name));
+    if (malformed.length > 0) {
+        problems.push(`variables ${malformed.join(', ')} must look like NAME_IN_CAPITALS`);
+    }
+    const settings = SETTINGS.safeParse(app);
+    if (!settings.success) {
+        problems.push(...settings.error.issues.map((issue) => `${issue.path.join('.')} ${issue.message}`));
+    }
+    if (problems.length > 0)
+        throw new Error(`the app: ${problems.join('; ')}`);
+    DEFINED.add(app);
+    return app;
+}

package/dist/shopify/config.d.ts

@@ -0,0 +1,53 @@
+import { z } from 'zod';
+import type { Language, ProductEnv } from '../product.js';
+import { type Env, type Mail } from '../server/config.js';
+import { type ShopifyStandardVariable } from '../variables.js';
+import type { ShopifyApp } from './app.js';
+import { type SealKey } from './seal.js';
+export interface ShopifyConfig<E extends ProductEnv = ProductEnv> {
+    mode: 'production' | 'local';
+    language: Language;
+    /** Every address of the app starts with it. */
+    publicOrigin: string;
+    port: number;
+    databaseUrl: string;
+    /** The name of the app in its mails and pages: MAIL_FROM_NAME. */
+    name: string;
+    mail: Mail;
+    /** Who runs the app, for its privacy text. */
+    operator: {
+        name: string;
+        address: string;
+    };
+    /** The bearer token of GET /vertrieb/zahlen. */
+    salesToken: string;
+    shopify: {
+        /** Null until the app is linked at Shopify: then /health/deep fails and no shop gets in. */
+        clientId: string | null;
+        /** The handle of the app in the admin. */
+        handle: string;
+        /** The scopes of shopify.app.toml, which the tokens of a shop must cover. */
+        scopes: string;
+        /** The client secret: it signs ID tokens and webhooks and takes the tokens of the shops. */
+        secret: string;
+        /** Seals the tokens of the shops in the database. */
+        tokenKey: SealKey;
+        /** The Partner API, which alone says the plan of a shop. */
+        partner: {
+            token: string;
+            organization: string;
+        };
+        /** Shopify itself, or in the tests of an app its double on this machine. */
+        api: {
+            kind: 'shopify';
+        } | {
+            kind: 'double';
+            url: string;
+        };
+    };
+    /** What runs without locally; empty in production. */
+    missing: readonly ShopifyStandardVariable[];
+    product: z.output<z.ZodObject<E>>;
+}
+/** Reads the configuration; ConfigError names every problem at once. `toml` is the text of the file. */
+export declare function loadShopifyConfig<E extends ProductEnv>(env: Env, app: ShopifyApp<E>, toml: string | undefined): ShopifyConfig<E>;

package/dist/shopify/config.js

@@ -0,0 +1,133 @@
+// Locally mail may be missing (mails go to the log); Shopify is needed in either mode, since
+// without it no page of the app opens.
+import { z } from 'zod';
+import { ConfigError, DEFAULT_PORT, MUST, problemsOf, SHAPE, valueOf } from '../server/config.js';
+import { SHOPIFY_STANDARD_VARIABLES } from '../variables.js';
+import { sealKey } from './seal.js';
+import { APP_TOML, appToml } from './toml.js';
+const SECRET = z.string().regex(/^\S{16,}$/);
+const OWN_SHAPE = {
+    SHOPIFY_API_SECRET: SECRET,
+    SHOPIFY_TOKEN_KEY: z.string().regex(/^[0-9a-f]{64}$/),
+    SHOPIFY_PARTNER_TOKEN: SECRET,
+    SHOPIFY_PARTNER_ORG: z.string().regex(/^\d{1,20}$/)
+};
+const OWN_MUST = {
+    SHOPIFY_API_SECRET: 'the client secret of the app, at least 16 characters without a blank',
+    SHOPIFY_TOKEN_KEY: '64 hex digits, the key that seals the tokens of the shops',
+    SHOPIFY_PARTNER_TOKEN: 'a token of the Partner API, at least 16 characters without a blank',
+    SHOPIFY_PARTNER_ORG: 'the number of the Partner organization'
+};
+const SHARED = {
+    PUBLIC_ORIGIN: SHAPE.PUBLIC_ORIGIN,
+    PORT: SHAPE.PORT,
+    DATABASE_URL: SHAPE.DATABASE_URL,
+    SMTP_HOST: SHAPE.SMTP_HOST,
+    SMTP_PORT: SHAPE.SMTP_PORT,
+    MAIL_FROM: SHAPE.MAIL_FROM,
+    MAIL_FROM_NAME: SHAPE.MAIL_FROM_NAME,
+    OPERATOR_NAME: SHAPE.OPERATOR_NAME,
+    OPERATOR_ADDRESS: SHAPE.OPERATOR_ADDRESS,
+    // Required like every standard variable, yet unread: the privacy text names the server of the fleet.
+    HOSTING_LOCATION: SHAPE.HOSTING_LOCATION,
+    VERTRIEB_TOKEN: SHAPE.VERTRIEB_TOKEN
+};
+const FULL_SHAPE = { ...SHARED, ...OWN_SHAPE };
+const MUST_OF = {
+    PUBLIC_ORIGIN: MUST.PUBLIC_ORIGIN,
+    PORT: MUST.PORT,
+    DATABASE_URL: MUST.DATABASE_URL,
+    SMTP_HOST: MUST.SMTP_HOST,
+    SMTP_PORT: MUST.SMTP_PORT,
+    MAIL_FROM: MUST.MAIL_FROM,
+    MAIL_FROM_NAME: MUST.MAIL_FROM_NAME,
+    OPERATOR_NAME: MUST.OPERATOR_NAME,
+    OPERATOR_ADDRESS: MUST.OPERATOR_ADDRESS,
+    HOSTING_LOCATION: MUST.HOSTING_LOCATION,
+    VERTRIEB_TOKEN: MUST.VERTRIEB_TOKEN,
+    ...OWN_MUST
+};
+const MAIL = ['SMTP_HOST', 'SMTP_PORT', 'MAIL_FROM'];
+const PRODUCTION = z.object(FULL_SHAPE);
+const LOCAL = z.object({
+    ...FULL_SHAPE,
+    PORT: FULL_SHAPE.PORT.optional(),
+    SMTP_HOST: FULL_SHAPE.SMTP_HOST.optional(),
+    SMTP_PORT: FULL_SHAPE.SMTP_PORT.optional(),
+    MAIL_FROM: FULL_SHAPE.MAIL_FROM.optional()
+});
+/** The Shopify double of the tests: only on this machine, so that no setting sends a token elsewhere. */
+const SHOPIFY_API_BASE = z
+    .url({ protocol: /^http$/, hostname: /^(?:127\.0\.0\.1|localhost|\[::1\])$/ })
+    .transform((value) => new URL(value).origin);
+function mailOf(data) {
+    const { SMTP_HOST: host, SMTP_PORT: port, MAIL_FROM: from } = data;
+    return host !== undefined && port !== undefined && from !== undefined
+        ? { kind: 'smtp', host, port, from }
+        : { kind: 'log' };
+}
+/** Reads the configuration; ConfigError names every problem at once. `toml` is the text of the file. */
+export function loadShopifyConfig(env, app, toml) {
+    const inProduction = env.NODE_ENV === 'production';
+    const input = Object.fromEntries(SHOPIFY_STANDARD_VARIABLES.map((name) => [name, valueOf(env, name)]));
+    const names = Object.keys(app.env);
+    const ownInput = Object.fromEntries(names.map((name) => [name, valueOf(env, name)]));
+    const base = (inProduction ? PRODUCTION : LOCAL).safeParse(input);
+    const own = z.object(app.env).safeParse(ownInput);
+    const apiBase = valueOf(env, 'SHOPIFY_API_BASE');
+    const double = apiBase === undefined ? null : SHOPIFY_API_BASE.safeParse(apiBase);
+    // The double gives the app a client ID of its own: until the app is linked, its file has none.
+    const testClientId = valueOf(env, 'SHOPIFY_CLIENT_ID');
+    const file = toml === undefined
+        ? { kind: 'problems', problems: [`${APP_TOML} is missing in the root of the app`] }
+        : appToml(toml);
+    const absent = MAIL.filter((name) => input[name] === undefined);
+    const problems = [
+        ...(base.success
+            ? []
+            : problemsOf(base.error.issues, SHOPIFY_STANDARD_VARIABLES, input, (name) => `${name} must be ${MUST_OF[name]}`)),
+        ...(double === null || double.success
+            ? []
+            : ['SHOPIFY_API_BASE must be an http origin on this machine, for the Shopify double']),
+        ...(testClientId !== undefined && double === null
+            ? [
+                `SHOPIFY_CLIENT_ID is only for the Shopify double of the tests; the client ID comes from ${APP_TOML}`
+            ]
+            : []),
+        ...(own.success
+            ? []
+            : problemsOf(own.error.issues, names, ownInput, (name, issue) => `${name} is invalid: ${issue.message}`)),
+        ...(file.kind === 'problems' ? file.problems : []),
+        ...(!inProduction && absent.length > 0 && absent.length < MAIL.length
+            ? [`mail is set only in part: ${absent.join(', ')} missing`]
+            : [])
+    ];
+    if (!base.success || !own.success || file.kind === 'problems' || problems.length > 0) {
+        throw new ConfigError(problems);
+    }
+    const data = base.data;
+    return {
+        mode: inProduction ? 'production' : 'local',
+        language: app.language,
+        publicOrigin: data.PUBLIC_ORIGIN,
+        port: data.PORT ?? DEFAULT_PORT,
+        databaseUrl: data.DATABASE_URL,
+        name: data.MAIL_FROM_NAME,
+        mail: mailOf(data),
+        operator: { name: data.OPERATOR_NAME, address: data.OPERATOR_ADDRESS },
+        salesToken: data.VERTRIEB_TOKEN,
+        shopify: {
+            clientId: testClientId ?? file.toml.clientId,
+            handle: file.toml.handle,
+            scopes: file.toml.scopes,
+            secret: data.SHOPIFY_API_SECRET,
+            tokenKey: sealKey(data.SHOPIFY_TOKEN_KEY),
+            partner: { token: data.SHOPIFY_PARTNER_TOKEN, organization: data.SHOPIFY_PARTNER_ORG },
+            api: double === null || !double.success
+                ? { kind: 'shopify' }
+                : { kind: 'double', url: double.data }
+        },
+        missing: inProduction ? [] : absent,
+        product: own.data
+    };
+}

package/dist/shopify/constants.d.ts

@@ -0,0 +1,27 @@
+/**
+ * The version of the Admin API, for every request of the baukasten and the app and for the webhooks.
+ * Shopify supports a version for twelve months: a newer one comes with a new version of the baukasten.
+ */
+export declare const SHOPIFY_API_VERSION = "2026-10";
+/** Every webhook of the app comes here, those of the baukasten and those of the app alike. */
+export declare const SHOPIFY_WEBHOOK_PATH = "/shopify/webhooks";
+/** The webhooks about privacy, which every app in the App Store answers. */
+export declare const COMPLIANCE_TOPICS: string[];
+/**
+ * The redirect URL of the app configuration. With managed installation Shopify never sends a merchant
+ * there, but the App Store wants one; it shows where the app is opened.
+ */
+export declare const SHOPIFY_AUTH_PATH = "/shopify/auth";
+/** The page with App Bridge alone, which fetches an ID token and opens the page it came for again. */
+export declare const SHOPIFY_BOUNCE_PATH = "/shopify/session-token";
+/** The CDN of Shopify, with App Bridge and Polaris, which the App Store wants in their latest version. */
+export declare const SHOPIFY_CDN = "https://cdn.shopify.com";
+/**
+ * Where on the CDN the scripts of Shopify lie: a page takes scripts from there alone, since the rest
+ * of the CDN serves what any merchant uploads.
+ */
+export declare const SHOPIFY_SCRIPTS = "https://cdn.shopify.com/shopifycloud/";
+export declare const APP_BRIDGE_URL = "https://cdn.shopify.com/shopifycloud/app-bridge.js";
+export declare const POLARIS_URL = "https://cdn.shopify.com/shopifycloud/polaris.js";
+/** The admin that frames the app, besides the domain of the shop itself. */
+export declare const SHOPIFY_ADMIN = "https://admin.shopify.com";

package/dist/shopify/constants.js

@@ -0,0 +1,27 @@
+/**
+ * The version of the Admin API, for every request of the baukasten and the app and for the webhooks.
+ * Shopify supports a version for twelve months: a newer one comes with a new version of the baukasten.
+ */
+export const SHOPIFY_API_VERSION = '2026-10';
+/** Every webhook of the app comes here, those of the baukasten and those of the app alike. */
+export const SHOPIFY_WEBHOOK_PATH = '/shopify/webhooks';
+/** The webhooks about privacy, which every app in the App Store answers. */
+export const COMPLIANCE_TOPICS = ['customers/data_request', 'customers/redact', 'shop/redact'];
+/**
+ * The redirect URL of the app configuration. With managed installation Shopify never sends a merchant
+ * there, but the App Store wants one; it shows where the app is opened.
+ */
+export const SHOPIFY_AUTH_PATH = '/shopify/auth';
+/** The page with App Bridge alone, which fetches an ID token and opens the page it came for again. */
+export const SHOPIFY_BOUNCE_PATH = '/shopify/session-token';
+/** The CDN of Shopify, with App Bridge and Polaris, which the App Store wants in their latest version. */
+export const SHOPIFY_CDN = 'https://cdn.shopify.com';
+/**
+ * Where on the CDN the scripts of Shopify lie: a page takes scripts from there alone, since the rest
+ * of the CDN serves what any merchant uploads.
+ */
+export const SHOPIFY_SCRIPTS = `${SHOPIFY_CDN}/shopifycloud/`;
+export const APP_BRIDGE_URL = `${SHOPIFY_SCRIPTS}app-bridge.js`;
+export const POLARIS_URL = `${SHOPIFY_SCRIPTS}polaris.js`;
+/** The admin that frames the app, besides the domain of the shop itself. */
+export const SHOPIFY_ADMIN = 'https://admin.shopify.com';

package/dist/shopify/headers.d.ts

@@ -0,0 +1 @@
+export declare const SHOPIFY_SECURITY_HEADERS: Readonly<Record<string, string>>;

package/dist/shopify/headers.js

@@ -0,0 +1,8 @@
+// The security headers of every response of a Shopify app, like those of a web app
+// (server/headers.ts), but without X-Frame-Options and Cross-Origin-Opener-Policy: the admin of
+// Shopify frames the app, and App Bridge opens the top window from it. Who may frame a page, its
+// content security policy says, per shop (hook.ts).
+export const SHOPIFY_SECURITY_HEADERS = {
+    'x-content-type-options': 'nosniff',
+    'referrer-policy': 'strict-origin-when-cross-origin'
+};

package/dist/shopify/hmac.d.ts

@@ -0,0 +1 @@
+export declare function webhookSigned(body: string | Uint8Array, header: string | null, secret: string): boolean;

package/dist/shopify/hmac.js

@@ -0,0 +1,9 @@
+// The signature of a webhook of Shopify: X-Shopify-Hmac-Sha256 is the HMAC-SHA256 of the raw body
+// with the client secret, in base64. Both sides are hashed to the same length before the comparison,
+// so that it takes the same time whatever was sent.
+import { createHash, createHmac, timingSafeEqual } from 'node:crypto';
+export function webhookSigned(body, header, secret) {
+    const expected = createHmac('sha256', secret).update(body).digest('base64');
+    const digest = (value) => createHash('sha256').update(value).digest();
+    return timingSafeEqual(digest(header ?? ''), digest(expected));
+}

package/dist/shopify/hook.d.ts

@@ -0,0 +1,60 @@
+import type { Handle, HandleServerError, ServerInit } from '@sveltejs/kit';
+import type { ProductEnv } from '../product.js';
+import { type Limits } from '../server/limits.js';
+import type { Log } from '../server/log.js';
+import type { Db, Mailer } from '../server/ports.js';
+import { type AdminApi } from './admin.js';
+import type { ShopifyApp } from './app.js';
+import { type ShopifyConfig } from './config.js';
+import { type Plan } from './shops.js';
+import { type WebhookHooks } from './webhooks.js';
+/** The shop of a request that got in. */
+export interface ShopSession {
+    /** Its permanent domain, like example.myshopify.com. */
+    domain: string;
+    plan: Exclude<Plan, {
+        kind: 'none';
+    }>;
+}
+export interface ShopifyContext<E extends ProductEnv = ProductEnv> {
+    config: ShopifyConfig<E>;
+    db: Db;
+    log: Log;
+    /** The sending of the baukasten, for the app's own mails. */
+    mail: Mailer;
+    /** The counters of the baukasten, for the limits of the app's own routes. */
+    limits: Limits;
+}
+/** What the baukasten calls in the app. */
+export interface ShopifyHooks<E extends ProductEnv = ProductEnv> extends WebhookHooks {
+    /**
+     * The checks of the app in GET /health/deep, by name; `database`, `mail` and `shopify` are the
+     * baukasten's.
+     */
+    checks?: Record<string, (context: ShopifyContext<E>) => Promise<void>>;
+    /** Once the configuration is read, before the first request: the app starts its runs. */
+    start?: (context: ShopifyContext<E>) => Promise<void> | void;
+    /** On SIGTERM, after the last request and before the pool closes: it stops its runs. */
+    stop?: (context: ShopifyContext<E>) => Promise<void> | void;
+}
+export interface ShopifyKit<E extends ProductEnv = ProductEnv> {
+    /**
+     * The `init` of the hooks. SvelteKit runs it in `vite build` too, with `building` of
+     * `$app/environment` set: then it reads nothing and opens nothing.
+     */
+    init(building: boolean): ServerInit;
+    handle: Handle;
+    handleError: HandleServerError;
+    /** Pool, configuration, log, mail and limits of the running app; only after `init`. */
+    context(): ShopifyContext<E>;
+    /**
+     * The shop of a request of a page or endpoint of the app: every one is opened by a shop that got
+     * in. Not in `locals`, whose type a web app of the same package shapes otherwise.
+     */
+    shop(event: {
+        request: Request;
+    }): ShopSession;
+    /** The Admin API of a shop, for the app's own queries, in a request or in a run. */
+    admin(shop: string): AdminApi;
+}
+export declare function shopifyBaukasten<E extends ProductEnv>(app: ShopifyApp<E>, hooks?: ShopifyHooks<E>): ShopifyKit<E>;