@tollwyn/baukasten 0.0.2 → 1.2.3

package/dist/shopify/hook.js

@@ -0,0 +1,508 @@
+import { randomBytes } from 'node:crypto';
+import { existsSync, readFileSync } from 'node:fs';
+import { setTimeout as wait } from 'node:timers/promises';
+import { createDb } from '../server/adapter/db.js';
+import { exitAfterLog, log } from '../server/adapter/log.js';
+import { createMailer } from '../server/adapter/mailer.js';
+import { migrationSources, migrationStatus } from '../server/adapter/migrate.js';
+import { ConfigError } from '../server/config.js';
+import { CHECK_TIMEOUT_MS, CheckFailed, databaseCheck, deepHealth, mailCheck } from '../server/health.js';
+import { createLimits } from '../server/limits.js';
+import { periodic } from '../server/runs.js';
+import { bearerFits, SALES_PATH } from '../server/sales.js';
+import { ShopifyFailed, shopifyApi } from './adapter/shopify.js';
+import { adminApi } from './admin.js';
+import { loadShopifyConfig } from './config.js';
+import { SHOPIFY_ADMIN, SHOPIFY_AUTH_PATH, SHOPIFY_BOUNCE_PATH, SHOPIFY_WEBHOOK_PATH } from './constants.js';
+import { SHOPIFY_SECURITY_HEADERS } from './headers.js';
+import { verifyIdToken } from './id-token.js';
+import { SHOPIFY_PRIVACY_DATE, shopifyPrivacy } from './legal/index.js';
+import { bouncePage, frameAncestors, legalPage, outsidePage, topPage, unavailablePage } from './pages.js';
+import { shopifySalesNumbers } from './sales.js';
+import { shopDomain, storeHandle } from './shop.js';
+import { createShops } from './shops.js';
+import { SHOPIFY_TEXTS } from './texts.js';
+import { APP_TOML } from './toml.js';
+import { createWebhooks } from './webhooks.js';
+const HEALTH = '/health';
+const DEEP = '/health/deep';
+const PRIVACY = '/privacy';
+/** The app's src/app.html, a stub, takes the language and the client ID from these. */
+const LANG = '%baukasten.lang%';
+const CLIENT_ID = '%baukasten.clientId%';
+/** Shopify's library answers an ID token that no longer works this way, and App Bridge tries again. */
+const RETRY = { 'x-shopify-retry-invalid-session-request': '1' };
+/** The parameters of the admin that a page of the app is opened with, which the bounce page drops. */
+const ADMIN_PARAMS = ['id_token'];
+const PROBE_TIMEOUT_MS = CHECK_TIMEOUT_MS - 1_000;
+/** The run of the webhooks beats this often, and touches the database only when it is marked. */
+const WEBHOOK_BEAT_MS = 1_000;
+const SAFE_METHODS = ['GET', 'HEAD', 'OPTIONS'];
+function json(body, status, headers = {}) {
+    return new Response(JSON.stringify(body), {
+        status,
+        headers: { 'content-type': 'application/json', 'cache-control': 'no-store', ...headers }
+    });
+}
+function laterOf(a, b) {
+    return a > b ? a : b;
+}
+export function shopifyBaukasten(app, hooks = {}) {
+    const appChecks = hooks.checks ?? {};
+    if ('database' in appChecks || 'mail' in appChecks || 'shopify' in appChecks) {
+        throw new Error('the checks database, mail and shopify belong to the baukasten');
+    }
+    // The privacy text promises a merchant what the app keeps of a customer, and its deletion.
+    if (app.privacy.data.length > 0 &&
+        (hooks.customerData === undefined || hooks.redactCustomer === undefined)) {
+        throw new Error('the app keeps personal data for the merchant (privacy.data): it gives the hooks customerData and redactCustomer');
+    }
+    let state = { kind: 'waiting' };
+    /** The shop of each request that got in, by its request, which its loads and actions share. */
+    const sessions = new WeakMap();
+    function running() {
+        switch (state.kind) {
+            case 'running':
+                return state;
+            case 'building':
+                throw new Error('the baukasten is used in the build: its pages read the configuration of the running app and cannot be prerendered');
+            case 'waiting':
+                throw new Error('the baukasten is used before init ran');
+        }
+    }
+    async function stop(applying, context) {
+        await applying.stop();
+        try {
+            await hooks.stop?.(context);
+        }
+        catch (error) {
+            process.exitCode = 1;
+            log.error('the stop hook of the app failed', { error });
+        }
+        await context.db.close();
+        log.info('stopped');
+    }
+    async function start() {
+        const root = process.cwd();
+        const toml = `${root}/${APP_TOML}`;
+        let config;
+        try {
+            config = loadShopifyConfig(process.env, app, existsSync(toml) ? readFileSync(toml, 'utf8') : undefined);
+        }
+        catch (error) {
+            if (!(error instanceof ConfigError))
+                throw error;
+            log.error('configuration incomplete, not starting', { problems: error.problems });
+            return exitAfterLog(1);
+        }
+        if (config.missing.length > 0) {
+            log.warn('running without what production needs', { missing: config.missing });
+        }
+        if (config.shopify.clientId === null) {
+            log.error(`the app is not linked at Shopify: ${APP_TOML} has no client_id, and no shop gets in`);
+        }
+        const db = createDb(config.databaseUrl, log);
+        const mail = createMailer(config.mail, config.name, log);
+        const limits = createLimits({ now: () => Date.now() });
+        const context = { config, db, log, mail, limits };
+        const api = shopifyApi(config.shopify, { now: () => new Date() });
+        const shops = createShops({
+            db,
+            api,
+            key: config.shopify.tokenKey,
+            plans: app.plans,
+            scopes: config.shopify.scopes,
+            log,
+            now: () => new Date(),
+            nonce: () => randomBytes(12)
+        });
+        const webhooks = createWebhooks({
+            db,
+            shops,
+            secret: config.shopify.secret,
+            hooks,
+            mail,
+            name: config.name,
+            language: config.language,
+            log,
+            now: () => new Date()
+        });
+        // Applies the webhooks after their answer. It looks when one came, and when one that failed is
+        // due to be tried again: the database sleeps in between.
+        let retry = null;
+        const applying = periodic({
+            name: 'shopify webhooks',
+            everyMs: WEBHOOK_BEAT_MS,
+            work: async () => {
+                const { retryAt, forgetAt } = await webhooks.work();
+                const times = [retryAt, forgetAt].flatMap((at) => (at === null ? [] : [at.getTime()]));
+                if (retry !== null)
+                    clearTimeout(retry);
+                retry =
+                    times.length === 0
+                        ? null
+                        : setTimeout(() => applying.mark(), Math.max(0, Math.min(...times) - Date.now()));
+                retry?.unref();
+            }
+        });
+        const stopRetry = () => {
+            if (retry !== null)
+                clearTimeout(retry);
+        };
+        const privacy = shopifyPrivacy({
+            language: config.language,
+            name: config.name,
+            origin: config.publicOrigin,
+            operator: config.operator,
+            privacy: app.privacy,
+            version: laterOf(SHOPIFY_PRIVACY_DATE, app.privacyDate)
+        });
+        const probe = db.withTimeout(PROBE_TIMEOUT_MS);
+        const sources = migrationSources(root, 'shopify');
+        const checks = Object.fromEntries(Object.entries(appChecks).map(([name, check]) => [name, () => check(context)]));
+        const shopifyHealth = async () => {
+            if (config.shopify.clientId === null) {
+                throw new CheckFailed(`no client_id in ${APP_TOML}: link the app at Shopify`);
+            }
+            // With a shop, the token must read its plan, which "Manage apps" grants; before the first
+            // shop, it must at least be taken.
+            const shop = await shops.anyInstalled();
+            try {
+                if (shop === null)
+                    await api.partnerCheck();
+                else
+                    await api.subscription(shop.appId, shop.shopId);
+            }
+            catch (error) {
+                log.error('shopify: the Partner API refused', { error });
+                throw new CheckFailed(error instanceof ShopifyFailed ? 'the Partner API refused' : 'unreachable');
+            }
+        };
+        const health = deepHealth({
+            checks: {
+                database: databaseCheck(probe, () => migrationStatus(probe, sources), log),
+                mail: mailCheck(mail, log),
+                shopify: shopifyHealth,
+                ...checks
+            },
+            now: () => Date.now(),
+            log
+        });
+        state = { kind: 'running', context, api, shops, webhooks, applying, privacy, health };
+        log.info('starting', {
+            mode: config.mode,
+            origin: config.publicOrigin,
+            language: config.language
+        });
+        applying.start({ db, log });
+        // Webhooks that were kept before a restart are applied now.
+        applying.mark();
+        await hooks.start?.(context);
+        process.once('sveltekit:shutdown', () => {
+            stopRetry();
+            void stop(applying, context);
+        });
+    }
+    const init = (building) => () => {
+        if (!building)
+            return start();
+        state = { kind: 'building' };
+    };
+    async function health(event) {
+        if (event.request.method !== 'GET' && event.request.method !== 'HEAD') {
+            return new Response(null, { status: 405, headers: { allow: 'GET, HEAD' } });
+        }
+        // Plain health answers without the database: Neon may sleep, the process still lives.
+        if (event.url.pathname === HEALTH)
+            return json({ status: 'ok' }, 200);
+        const report = await running().health();
+        return json(report, report.status === 'ok' ? 200 : 503);
+    }
+    async function webhook(s, event) {
+        if (event.request.method !== 'POST') {
+            return new Response(null, { status: 405, headers: { allow: 'POST' } });
+        }
+        const body = new Uint8Array(await event.request.arrayBuffer());
+        const received = await s.webhooks.receive(body, event.request.headers);
+        switch (received.kind) {
+            case 'unsigned':
+                log.warn('shopify: a webhook without the signature of the app');
+                return new Response(null, { status: 401 });
+            case 'malformed':
+                log.warn('shopify: a webhook of an unknown form', { reason: received.reason });
+                return new Response(null, { status: 400 });
+            case 'queued':
+                s.applying.mark();
+                return new Response(null, { status: 200 });
+            case 'repeated':
+                return new Response(null, { status: 200 });
+        }
+    }
+    async function sales(s, event) {
+        if (event.request.method !== 'GET') {
+            return new Response(null, { status: 405, headers: { allow: 'GET' } });
+        }
+        if (!bearerFits(event.request.headers.get('authorization'), s.context.config.salesToken)) {
+            return json({ error: { code: 'unauthorized', message: 'unauthorized' } }, 401);
+        }
+        return json(await shopifySalesNumbers(s.context.db, app.plans, new Date()), 200);
+    }
+    /** The answers of the baukasten itself, or null for a page of the app. */
+    function own(s, event) {
+        const { config } = s.context;
+        const texts = SHOPIFY_TEXTS[config.language];
+        switch (event.url.pathname) {
+            case SHOPIFY_WEBHOOK_PATH:
+                return webhook(s, event);
+            case SALES_PATH:
+                return sales(s, event);
+            case PRIVACY:
+                return legalPage({ name: config.name, language: config.language, legal: s.privacy });
+            case SHOPIFY_AUTH_PATH:
+                return outsidePage({ name: config.name, language: config.language, texts });
+            case SHOPIFY_BOUNCE_PATH: {
+                const shop = shopDomain(event.url.searchParams.get('shop'));
+                // App Bridge opens shopify-reload with a fresh ID token: only an address of this app.
+                const reload = event.url.searchParams.get('shopify-reload');
+                const ours = reload !== null && URL.canParse(reload) && new URL(reload).origin === config.publicOrigin;
+                if (shop === null || !ours || config.shopify.clientId === null) {
+                    return outsidePage({ name: config.name, language: config.language, texts });
+                }
+                return bouncePage({ clientId: config.shopify.clientId, shop, language: config.language });
+            }
+            default:
+                return null;
+        }
+    }
+    /** Back to the same page through the bounce page, with a fresh ID token. */
+    function bounce(s, url) {
+        const params = new URLSearchParams(url.searchParams);
+        for (const name of ADMIN_PARAMS)
+            params.delete(name);
+        const reload = `${s.context.config.publicOrigin}${url.pathname}?${params.toString()}`;
+        params.set('shopify-reload', reload);
+        return new Response(null, {
+            status: 302,
+            headers: { location: `${SHOPIFY_BOUNCE_PATH}?${params.toString()}` }
+        });
+    }
+    async function gate(s, event, clientId) {
+        const { config } = s.context;
+        const url = event.url;
+        const bearer = /^Bearer (\S+)$/.exec(event.request.headers.get('authorization') ?? '')?.[1];
+        const check = (token) => verifyIdToken(token, { clientId, secret: config.shopify.secret, now: new Date() });
+        if (bearer !== undefined) {
+            const checked = check(bearer);
+            if (checked.kind === 'invalid') {
+                log.info('shopify: a request with an ID token that does not hold', {
+                    reason: checked.reason
+                });
+                return { kind: 'answer', response: new Response(null, { status: 401, headers: RETRY }) };
+            }
+            return entered(s, url, checked.shop, bearer, false);
+        }
+        // A page opened in the admin: Shopify adds the shop, embedded=1 and an ID token to its URL.
+        const shop = shopDomain(url.searchParams.get('shop'));
+        if (url.searchParams.get('embedded') !== '1') {
+            if (shop === null) {
+                const texts = SHOPIFY_TEXTS[config.language];
+                return {
+                    kind: 'answer',
+                    response: outsidePage({ name: config.name, language: config.language, texts })
+                };
+            }
+            // Into the admin of the shop, where the app opens in its frame.
+            const location = `${SHOPIFY_ADMIN}/store/${storeHandle(shop)}/apps/${config.shopify.handle}${url.pathname === '/' ? '' : url.pathname}`;
+            return {
+                kind: 'answer',
+                response: new Response(null, { status: 302, headers: { location } })
+            };
+        }
+        const token = url.searchParams.get('id_token');
+        if (token === null || token === '')
+            return { kind: 'answer', response: bounce(s, url) };
+        const checked = check(token);
+        if (checked.kind === 'invalid') {
+            log.info('shopify: a page with an ID token that does not hold', { reason: checked.reason });
+            return { kind: 'answer', response: bounce(s, url) };
+        }
+        return entered(s, url, checked.shop, token, true);
+    }
+    async function entered(s, url, shop, idToken, document) {
+        const { config } = s.context;
+        const entry = await s.shops.enter(shop, idToken);
+        switch (entry.kind) {
+            case 'in':
+                return { kind: 'in', shop, document };
+            case 'invalid':
+                return {
+                    kind: 'answer',
+                    response: document ? bounce(s, url) : new Response(null, { status: 401, headers: RETRY })
+                };
+            case 'failed':
+                log.error('shopify: a shop did not get in', { shop, reason: entry.reason });
+                return {
+                    kind: 'answer',
+                    response: unavailablePage({
+                        language: config.language,
+                        texts: SHOPIFY_TEXTS[config.language],
+                        shop
+                    })
+                };
+        }
+    }
+    async function planned(s, event, shop, document, clientId) {
+        const { config } = s.context;
+        let plan;
+        try {
+            // Back from the plan page of Shopify, the page asks the plan again at once; its requests,
+            // which may carry the parameter as well, take what it found.
+            plan = await s.shops.plan(shop, document && event.url.searchParams.has('plan_handle'));
+        }
+        catch (error) {
+            log.error('shopify: the plan of a shop could not be read', { shop, error });
+            return {
+                kind: 'answer',
+                response: unavailablePage({
+                    language: config.language,
+                    texts: SHOPIFY_TEXTS[config.language],
+                    shop
+                })
+            };
+        }
+        if (plan.kind === 'active')
+            return { kind: 'plan', plan };
+        if (!document)
+            return { kind: 'answer', response: new Response(null, { status: 402 }) };
+        const pricing = `${SHOPIFY_ADMIN}/store/${storeHandle(shop)}/charges/${config.shopify.handle}/pricing_plans`;
+        return {
+            kind: 'answer',
+            response: topPage({
+                clientId,
+                shop,
+                url: pricing,
+                language: config.language,
+                nonce: randomBytes(16).toString('base64')
+            })
+        };
+    }
+    /**
+     * A page without its content security policy does not go out: the policy comes from
+     * SHOPIFY_SVELTEKIT_OPTIONS in the configuration of the app; with it, only the admin of the shop
+     * may frame the page.
+     */
+    let policyMissing = false;
+    function framed(response, shop, path) {
+        const page = response.headers.get('content-type')?.startsWith('text/html') === true;
+        if (!page)
+            return response;
+        const policy = response.headers.get('content-security-policy');
+        if (policy === null) {
+            if (response.status >= 500)
+                return response;
+            if (!policyMissing) {
+                policyMissing = true;
+                log.error('a page without its content security policy: SHOPIFY_SVELTEKIT_OPTIONS of the baukasten is missing in sveltekit() of vite.config.ts, or an endpoint of the app answers HTML of its own; every such answer is a 500', { path });
+            }
+            return new Response('Internal Error', {
+                status: 500,
+                headers: { 'content-type': 'text/plain; charset=utf-8' }
+            });
+        }
+        response.headers.set('content-security-policy', `${policy}; ${frameAncestors(shop)}`);
+        return response;
+    }
+    async function respondTo(event, resolve) {
+        const path = event.url.pathname;
+        if (path === HEALTH || path === DEEP)
+            return health(event);
+        const s = running();
+        const { config } = s.context;
+        const answer = own(s, event);
+        if (answer !== null)
+            return answer;
+        const clientId = config.shopify.clientId;
+        if (clientId === null) {
+            return unavailablePage({
+                language: config.language,
+                texts: SHOPIFY_TEXTS[config.language],
+                shop: null
+            });
+        }
+        // Unsafe requests of the app come from its own pages in the frame; another origin is refused.
+        if (!SAFE_METHODS.includes(event.request.method) &&
+            event.request.headers.get('origin') !== config.publicOrigin) {
+            log.warn('request refused: from another origin', { path });
+            return new Response('Forbidden', {
+                status: 403,
+                headers: { 'content-type': 'text/plain; charset=utf-8' }
+            });
+        }
+        const gated = await gate(s, event, clientId);
+        if (gated.kind === 'answer')
+            return gated.response;
+        const plan = await planned(s, event, gated.shop, gated.document, clientId);
+        if (plan.kind === 'answer')
+            return plan.response;
+        sessions.set(event.request, { domain: gated.shop, plan: plan.plan });
+        const response = await resolve(event, {
+            transformPageChunk: ({ html }) => html.replace(LANG, config.language).replace(CLIENT_ID, clientId)
+        });
+        return framed(response, gated.shop, path);
+    }
+    const handle = async ({ event, resolve }) => {
+        // Prerendering in the build is no request of anyone.
+        if (state.kind === 'building')
+            return resolve(event);
+        const started = performance.now();
+        let status = 500;
+        try {
+            const response = await respondTo(event, resolve);
+            for (const [name, value] of Object.entries(SHOPIFY_SECURITY_HEADERS)) {
+                response.headers.set(name, value);
+            }
+            status = response.status;
+            return response;
+        }
+        finally {
+            // The container polls /health; it is logged only at debug. The path goes without its query,
+            // which carries the ID token; the shop of a request that got in goes with it, the privacy
+            // text says so, and a request that did not get in has none.
+            (event.url.pathname === HEALTH ? log.debug : log.info)('request', {
+                method: event.request.method,
+                path: event.url.pathname,
+                status,
+                ms: Math.round(performance.now() - started),
+                shop: sessions.get(event.request)?.domain
+            });
+        }
+    };
+    const handleError = ({ error, event, status, message }) => {
+        if (status === 404)
+            return { message };
+        (status >= 500 ? log.error : log.warn)('request failed', {
+            method: event.request.method,
+            path: event.url.pathname,
+            status,
+            error
+        });
+        return { message: status >= 500 ? 'Internal Error' : message };
+    };
+    return {
+        init,
+        handle,
+        handleError,
+        context: () => running().context,
+        shop: (event) => {
+            const session = sessions.get(event.request);
+            if (session === undefined) {
+                throw new Error('no shop got in with this request: kit.shop serves the pages of the app');
+            }
+            return session;
+        },
+        admin: (shop) => {
+            const s = running();
+            return adminApi(shop, { api: s.api, shops: s.shops, log, wait: (ms) => wait(ms) });
+        }
+    };
+}

package/dist/shopify/id-token.d.ts

@@ -0,0 +1,12 @@
+export type IdTokenCheck = {
+    kind: 'valid';
+    shop: string;
+} | {
+    kind: 'invalid';
+    reason: 'form' | 'algorithm' | 'signature' | 'expired' | 'not yet valid' | 'audience' | 'destination' | 'issuer';
+};
+export declare function verifyIdToken(token: string, app: {
+    clientId: string;
+    secret: string;
+    now: Date;
+}): IdTokenCheck;

package/dist/shopify/id-token.js

@@ -0,0 +1,66 @@
+// The ID token of Shopify (formerly the session token): a JWT that App Bridge fetches in the admin and
+// the app receives with a request, as `id_token` in the URL of a page or as a bearer token. HS256 with
+// the client secret of the app; it lives a minute. The checks are those of Shopify's own library:
+// signature, time with ten seconds for clocks that differ, the app as audience, and issuer and
+// destination on the same shop. The reason names what failed and never the token.
+import { createHmac, timingSafeEqual } from 'node:crypto';
+import { z } from 'zod';
+import { shopDomain } from './shop.js';
+/** Clocks of Shopify and of the server may differ by this much. */
+const TOLERANCE_SECONDS = 10;
+const HEADER = z.object({ alg: z.string() });
+const CLAIMS = z.object({
+    iss: z.url(),
+    dest: z.url(),
+    aud: z.string(),
+    exp: z.number(),
+    nbf: z.number()
+});
+function decoded(part) {
+    try {
+        return JSON.parse(Buffer.from(part, 'base64url').toString('utf8'));
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Whether `signature` is the HS256 of `unsigned`, compared in constant time. */
+function signed(unsigned, signature, secret) {
+    const expected = createHmac('sha256', secret).update(unsigned).digest();
+    const given = Buffer.from(signature, 'base64url');
+    return given.length === expected.length && timingSafeEqual(given, expected);
+}
+export function verifyIdToken(token, app) {
+    const parts = token.split('.');
+    if (parts.length !== 3)
+        return { kind: 'invalid', reason: 'form' };
+    const [header = '', payload = '', signature = ''] = parts;
+    const head = HEADER.safeParse(decoded(header));
+    if (!head.success)
+        return { kind: 'invalid', reason: 'form' };
+    if (head.data.alg !== 'HS256')
+        return { kind: 'invalid', reason: 'algorithm' };
+    if (!signed(`${header}.${payload}`, signature, app.secret)) {
+        return { kind: 'invalid', reason: 'signature' };
+    }
+    const claims = CLAIMS.safeParse(decoded(payload));
+    if (!claims.success)
+        return { kind: 'invalid', reason: 'form' };
+    const { iss, dest, aud, exp, nbf } = claims.data;
+    const now = app.now.getTime() / 1000;
+    if (exp + TOLERANCE_SECONDS <= now)
+        return { kind: 'invalid', reason: 'expired' };
+    if (nbf - TOLERANCE_SECONDS > now)
+        return { kind: 'invalid', reason: 'not yet valid' };
+    if (aud !== app.clientId)
+        return { kind: 'invalid', reason: 'audience' };
+    const destination = new URL(dest);
+    const shop = shopDomain(destination.protocol === 'https:' ? destination.hostname : null);
+    if (shop === null)
+        return { kind: 'invalid', reason: 'destination' };
+    const issuer = new URL(iss);
+    if (issuer.protocol !== 'https:' || issuer.hostname !== shop) {
+        return { kind: 'invalid', reason: 'issuer' };
+    }
+    return { kind: 'valid', shop };
+}

package/dist/shopify/index.d.ts

@@ -0,0 +1,19 @@
+import { type NodeHandler } from '../server/start.js';
+export { log } from '../server/adapter/log.js';
+export { CheckFailed } from '../server/health.js';
+export { LIMITS, type Limits, type Rule } from '../server/limits.js';
+export type { Log } from '../server/log.js';
+export { MailFailed } from '../server/mail.js';
+export type { Db, Mail, Mailer, Queryable } from '../server/ports.js';
+export { periodic, type Run, type RunOptions } from '../server/runs.js';
+export type { NodeHandler } from '../server/start.js';
+export { AdminRefused, ShopGone, type AdminApi } from './admin.js';
+export type { ShopifyConfig } from './config.js';
+export { SHOPIFY_API_VERSION, SHOPIFY_WEBHOOK_PATH } from './constants.js';
+export { shopifyBaukasten, type ShopifyContext, type ShopifyHooks, type ShopifyKit, type ShopSession } from './hook.js';
+export type { Plan } from './shops.js';
+export type { CustomerRequest, Delivery } from './webhooks.js';
+/** The server of a Shopify app, called by its stub server.js with the handler of adapter-node. */
+export declare function start(load: () => Promise<{
+    handler: NodeHandler;
+}>): Promise<void>;

package/dist/shopify/index.js

@@ -0,0 +1,15 @@
+// The server entry of a Shopify app; nothing here may reach the browser.
+import { serve } from '../server/start.js';
+import { SHOPIFY_SECURITY_HEADERS } from './headers.js';
+export { log } from '../server/adapter/log.js';
+export { CheckFailed } from '../server/health.js';
+export { LIMITS } from '../server/limits.js';
+export { MailFailed } from '../server/mail.js';
+export { periodic } from '../server/runs.js';
+export { AdminRefused, ShopGone } from './admin.js';
+export { SHOPIFY_API_VERSION, SHOPIFY_WEBHOOK_PATH } from './constants.js';
+export { shopifyBaukasten } from './hook.js';
+/** The server of a Shopify app, called by its stub server.js with the handler of adapter-node. */
+export function start(load) {
+    return serve(load, SHOPIFY_SECURITY_HEADERS);
+}

package/dist/shopify/legal/de.d.ts

@@ -0,0 +1,3 @@
+import type { LegalData } from '../../ui/data.js';
+import type { ShopifyLegalFacts } from './index.js';
+export declare function de(f: ShopifyLegalFacts): LegalData;