@tollwyn/baukasten 0.0.2 → 1.2.2

package/dist/shopify/ports.d.ts

@@ -0,0 +1,77 @@
+/** The offline tokens of a shop, as Shopify gives them: both expire, the refresh token later. */
+export interface ShopTokens {
+    accessToken: string;
+    accessExpiresAt: Date;
+    refreshToken: string;
+    refreshExpiresAt: Date;
+    /** The scopes granted, as Shopify lists them. */
+    scope: string;
+}
+/**
+ * Why Shopify gave no tokens: `invalid` for an ID token or refresh token it no longer takes (the shop
+ * must open the app again), `failed` for anything else, which a later try may get past.
+ */
+export type TokenRefusal = {
+    kind: 'invalid';
+} | {
+    kind: 'failed';
+    reason: string;
+};
+export type TokenAnswer = {
+    kind: 'tokens';
+    tokens: ShopTokens;
+} | TokenRefusal;
+/** What the baukasten keeps of a shop when it installs the app. */
+export interface ShopInfo {
+    /** gid://shopify/Shop/… */
+    shopId: string;
+    /** gid://shopify/App/…, this app as Shopify knows it. */
+    appId: string;
+    /** The address of the shop, where requests about the data of its customers go. */
+    email: string;
+    /** A development store of a partner, which never pays. */
+    development: boolean;
+}
+/** The subscription of a shop as Shopify App Pricing says it. */
+export type Subscription = {
+    kind: 'none';
+} | {
+    kind: 'active';
+    /** The handles of its items: the plan, and events of usage if it has any. */
+    handles: string[];
+    /** Until when it runs as a trial; null without one. */
+    trialEndsAt: Date | null;
+};
+export type GraphqlAnswer = {
+    kind: 'data';
+    data: unknown;
+} | {
+    kind: 'errors';
+    errors: {
+        message: string;
+        code: string | null;
+    }[];
+}
+/** The access token no longer works: the shop removed the app, or it expired. */
+ | {
+    kind: 'unauthorized';
+}
+/** Over the limit of the shop: try again after this many milliseconds. */
+ | {
+    kind: 'throttled';
+    waitMs: number;
+};
+export interface ShopifyApi {
+    /** The offline tokens of `shop` for an ID token from the admin (token exchange). */
+    exchange(shop: string, idToken: string): Promise<TokenAnswer>;
+    /** New offline tokens of `shop` for its refresh token; the old ones end. */
+    refresh(shop: string, refreshToken: string): Promise<TokenAnswer>;
+    /** What the baukasten keeps of a shop that installed the app; null when the token no longer works. */
+    shopInfo(shop: string, accessToken: string): Promise<ShopInfo | null>;
+    /** A query of the Admin API in the version of the baukasten. */
+    graphql(shop: string, accessToken: string, query: string, variables: Readonly<Record<string, unknown>>): Promise<GraphqlAnswer>;
+    /** The subscription of a shop through the Partner API. */
+    subscription(appId: string, shopId: string): Promise<Subscription>;
+    /** Whether the Partner API takes the token: a query without data of a shop, for /health/deep. */
+    partnerCheck(): Promise<void>;
+}

package/dist/shopify/ports.js

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

package/dist/shopify/sales.d.ts

@@ -0,0 +1,4 @@
+import type { Queryable } from '../server/ports.js';
+import { type SalesNumbers } from '../server/sales.js';
+import type { ShopifyPlan } from './app.js';
+export declare function shopifySalesNumbers(db: Queryable, plans: readonly ShopifyPlan[], now: Date): Promise<SalesNumbers>;

package/dist/shopify/sales.js

@@ -0,0 +1,27 @@
+import { SALES_NUMBERS } from '../server/sales.js';
+import { NO_VIA } from '../server/via.js';
+export async function shopifySalesNumbers(db, plans, now) {
+    const paid = plans.filter((plan) => plan.paid).map((plan) => plan.handle);
+    const [counted] = await db.query(`SELECT count(*)::int AS konten,
+			count(*) FILTER (WHERE plan_handles && $1::text[]
+				AND (plan_trial_ends_at IS NULL OR plan_trial_ends_at <= $2))::int AS zahlende
+		 FROM baukasten.shops WHERE uninstalled_at IS NULL AND NOT development`, [paid, now]);
+    if (counted === undefined)
+        throw new Error('counting the shops gave no row');
+    const [konten, zahlende] = SALES_NUMBERS;
+    return {
+        stand: now.toISOString(),
+        je_kennung: counted.konten === 0
+            ? []
+            : [
+                {
+                    kennung: NO_VIA,
+                    werte: [
+                        { name: konten, wert: counted.konten },
+                        { name: zahlende, wert: counted.zahlende }
+                    ],
+                    umsatz: null
+                }
+            ]
+    };
+}

package/dist/shopify/scopes.d.ts

@@ -0,0 +1,2 @@
+/** Whether `granted` (as Shopify lists it) covers every scope of `required`. */
+export declare function scopesCover(granted: string, required: string): boolean;

package/dist/shopify/scopes.js

@@ -0,0 +1,13 @@
+// With managed installation the merchant approves new scopes when the app opens, and only a new
+// token exchange gives tokens with them. Writing a resource includes reading it, as at Shopify.
+function scopes(list) {
+    return new Set(list
+        .split(',')
+        .map((scope) => scope.trim())
+        .filter((scope) => scope !== ''));
+}
+/** Whether `granted` (as Shopify lists it) covers every scope of `required`. */
+export function scopesCover(granted, required) {
+    const have = scopes(granted);
+    return [...scopes(required)].every((scope) => have.has(scope) || (scope.includes('read_') && have.has(scope.replace('read_', 'write_'))));
+}

package/dist/shopify/seal.d.ts

@@ -0,0 +1,12 @@
+/** The key of the tokens, made only from its hex digits. */
+export interface SealKey {
+    readonly bytes: Buffer;
+}
+export declare function sealKey(hex: string): SealKey;
+/**
+ * Seals `text` under `key` with a fresh `nonce` of 12 random bytes, bound to `place`, like
+ * `example.myshopify.com access`.
+ */
+export declare function seal(key: SealKey, text: string, nonce: Uint8Array, place: string): string;
+/** What `seal` sealed under `key` for `place`; anything else throws. */
+export declare function open(key: SealKey, sealed: string, place: string): string;

package/dist/shopify/seal.js

@@ -0,0 +1,60 @@
+// The access and refresh tokens of the shops lie in the database sealed with AES-256-GCM under
+// SHOPIFY_TOKEN_KEY, which the delivery service makes for the app: a dump of the database alone hands
+// no one a token. A sealed token carries its version, its nonce and its tag, and is bound to where it
+// belongs (its shop and column): a changed one, or one moved to another shop, does not open.
+import { createCipheriv, createDecipheriv } from 'node:crypto';
+const VERSION = 'v1';
+const NONCE_BYTES = 12;
+const TAG_BYTES = 16;
+const ALGORITHM = 'aes-256-gcm';
+class Unsealed extends Error {
+    name = 'Unsealed';
+}
+export function sealKey(hex) {
+    if (!/^[0-9a-f]{64}$/.test(hex))
+        throw new Error('the key of the tokens is 64 hex digits');
+    return { bytes: Buffer.from(hex, 'hex') };
+}
+/**
+ * Seals `text` under `key` with a fresh `nonce` of 12 random bytes, bound to `place`, like
+ * `example.myshopify.com access`.
+ */
+export function seal(key, text, nonce, place) {
+    if (nonce.length !== NONCE_BYTES)
+        throw new Error(`the nonce is ${NONCE_BYTES} bytes`);
+    const cipher = createCipheriv(ALGORITHM, key.bytes, nonce, { authTagLength: TAG_BYTES });
+    cipher.setAAD(Buffer.from(place, 'utf8'));
+    const sealed = Buffer.concat([cipher.update(text, 'utf8'), cipher.final()]);
+    return [
+        VERSION,
+        Buffer.from(nonce).toString('base64url'),
+        cipher.getAuthTag().toString('base64url'),
+        sealed.toString('base64url')
+    ].join('.');
+}
+/** What `seal` sealed under `key` for `place`; anything else throws. */
+export function open(key, sealed, place) {
+    const [version, nonce, tag, text, ...rest] = sealed.split('.');
+    if (version !== VERSION || nonce === undefined || tag === undefined || text === undefined) {
+        throw new Unsealed('a sealed token does not open: not of this form');
+    }
+    if (rest.length > 0)
+        throw new Unsealed('a sealed token does not open: not of this form');
+    try {
+        // A shorter tag than GCM's whole one would make a forgery easier.
+        const decipher = createDecipheriv(ALGORITHM, key.bytes, Buffer.from(nonce, 'base64url'), {
+            authTagLength: TAG_BYTES
+        });
+        decipher.setAAD(Buffer.from(place, 'utf8'));
+        decipher.setAuthTag(Buffer.from(tag, 'base64url'));
+        return Buffer.concat([
+            decipher.update(Buffer.from(text, 'base64url')),
+            decipher.final()
+        ]).toString('utf8');
+    }
+    catch (error) {
+        throw new Unsealed('a sealed token does not open: another key or place, or changed', {
+            cause: error
+        });
+    }
+}

package/dist/shopify/shop.d.ts

@@ -0,0 +1,4 @@
+/** The shop of `value`, or null for anything that is not a domain under myshopify.com. */
+export declare function shopDomain(value: string | null): string | null;
+/** The handle of a shop in the admin, admin.shopify.com/store/<handle>: its domain without the suffix. */
+export declare function storeHandle(shop: string): string;

package/dist/shopify/shop.js

@@ -0,0 +1,15 @@
+// The name of a shop, the one way the baukasten takes it: its permanent domain under myshopify.com,
+// which Shopify sends with every ID token and webhook. A domain from a request becomes a header, a
+// URL to call with a token and a key in the database, so anything else is refused.
+const SHOP = /^([a-z0-9][a-z0-9-]*)\.myshopify\.com$/;
+/** The shop of `value`, or null for anything that is not a domain under myshopify.com. */
+export function shopDomain(value) {
+    return value !== null && SHOP.test(value) ? value : null;
+}
+/** The handle of a shop in the admin, admin.shopify.com/store/<handle>: its domain without the suffix. */
+export function storeHandle(shop) {
+    const handle = SHOP.exec(shop)?.[1];
+    if (handle === undefined)
+        throw new Error('not the domain of a shop');
+    return handle;
+}

package/dist/shopify/shops.d.ts

@@ -0,0 +1,76 @@
+import type { Log } from '../server/log.js';
+import type { Db, Queryable } from '../server/ports.js';
+import type { ShopifyPlan } from './app.js';
+import type { ShopifyApi } from './ports.js';
+import { type SealKey } from './seal.js';
+/** A token is refreshed when it ends within this time, so that no request runs into its end. */
+export declare const REFRESH_BEFORE_MS: number;
+/** The plan of a shop is asked again after this time, and at once after the plan page. */
+export declare const PLAN_FRESH_MS: number;
+export type Plan = {
+    kind: 'none';
+} | {
+    kind: 'active';
+    handle: string;
+    /** Until when it runs as a trial; null without one. */
+    trialEndsAt: Date | null;
+};
+export type Entry = {
+    kind: 'in';
+}
+/** Shopify no longer takes the ID token: App Bridge fetches a new one. */
+ | {
+    kind: 'invalid';
+}
+/** Shopify did not answer as it should; the merchant tries again later. */
+ | {
+    kind: 'failed';
+    reason: string;
+};
+export interface Shops {
+    /**
+     * Lets the shop of a valid ID token in: with tokens that work and cover the scopes of the app,
+     * refreshed if they end soon, or new ones from the token exchange, which installs the shop when it
+     * is new or came back.
+     */
+    enter(shop: string, idToken: string): Promise<Entry>;
+    /** A working access token of an installed shop; null when only the merchant can get a new one. */
+    accessToken(shop: string): Promise<string | null>;
+    /**
+     * Forgets the tokens of a shop, since Shopify refused `failed`: only if they are still those, and
+     * says whether it did; a newer token, refreshed meanwhile, stays.
+     */
+    forgetTokens(shop: string, failed: string): Promise<boolean>;
+    /** The plan of the shop, remembered for PLAN_FRESH_MS unless `fresh`. */
+    plan(shop: string, fresh: boolean): Promise<Plan>;
+    /**
+     * The end of an installation that Shopify triggered at `triggeredAt`: its tokens are gone, its data
+     * stay until shop/redact. False when the shop got its tokens from the token exchange after it, so
+     * that it removed the app and added it again before the end was applied; then it stays installed.
+     */
+    uninstall(tx: Queryable, shop: string, triggeredAt: Date): Promise<boolean>;
+    /** Deletes the shop and, through its references, all the app keeps of it. */
+    redact(tx: Queryable, shop: string): Promise<void>;
+    /**
+     * The address of the shop, for requests about the data of its customers: as Shopify gives it now
+     * while the app has a token that works, else the last it gave; null for an unknown shop.
+     */
+    email(q: Queryable, shop: string): Promise<string | null>;
+    /** A shop that has the app, for the check of the Partner API; null before the first. */
+    anyInstalled(): Promise<{
+        appId: string;
+        shopId: string;
+    } | null>;
+}
+export declare function createShops(deps: {
+    db: Db;
+    api: ShopifyApi;
+    key: SealKey;
+    plans: readonly ShopifyPlan[];
+    /** The scopes the app asks for, from shopify.app.toml. */
+    scopes: string;
+    log: Log;
+    now: () => Date;
+    /** 12 random bytes for each sealed token. */
+    nonce: () => Uint8Array;
+}): Shops;

package/dist/shopify/shops.js

@@ -0,0 +1,256 @@
+import { scopesCover } from './scopes.js';
+import { open, seal } from './seal.js';
+/** A token is refreshed when it ends within this time, so that no request runs into its end. */
+export const REFRESH_BEFORE_MS = 5 * 60_000;
+/** The plan of a shop is asked again after this time, and at once after the plan page. */
+export const PLAN_FRESH_MS = 10 * 60_000;
+export function createShops(deps) {
+    const { db, api, key, log, now } = deps;
+    /** Where a token belongs: a sealed one opens only there. */
+    const place = (shop, column) => `${shop} ${column}`;
+    /** The refresh of each shop that runs in this process; a second caller waits for it. */
+    const refreshing = new Map();
+    async function row(q, shop, lock = false) {
+        const [found] = await q.query(`SELECT domain, shop_id, app_id, email, scope, access_token, access_expires_at,
+				refresh_token, refresh_expires_at, uninstalled_at, plan_handles, plan_trial_ends_at,
+				plan_checked_at
+			 FROM baukasten.shops WHERE domain = $1${lock ? ' FOR UPDATE' : ''}`, [shop]);
+        return found ?? null;
+    }
+    const fresh = (expires) => expires !== null && expires.getTime() - now().getTime() > REFRESH_BEFORE_MS;
+    function freshToken(found) {
+        const access = found.access_token;
+        if (found.uninstalled_at !== null || access === null || !fresh(found.access_expires_at)) {
+            return null;
+        }
+        return open(key, access, place(found.domain, 'access'));
+    }
+    async function storeTokens(q, shop, tokens) {
+        await q.query(`UPDATE baukasten.shops SET access_token = $2, access_expires_at = $3, refresh_token = $4,
+				refresh_expires_at = $5, scope = $6
+			 WHERE domain = $1`, [
+            shop,
+            seal(key, tokens.accessToken, deps.nonce(), place(shop, 'access')),
+            tokens.accessExpiresAt,
+            seal(key, tokens.refreshToken, deps.nonce(), place(shop, 'refresh')),
+            tokens.refreshExpiresAt,
+            tokens.scope
+        ]);
+    }
+    async function clearTokens(q, shop) {
+        await q.query(`UPDATE baukasten.shops SET access_token = NULL, access_expires_at = NULL,
+				refresh_token = NULL, refresh_expires_at = NULL
+			 WHERE domain = $1`, [shop]);
+    }
+    /**
+     * Refreshes the token under the lock of the row, looking again first: a refresh of another
+     * process may have come before. A refresh that fails for another reason than an invalid token
+     * throws, and the tokens stay.
+     */
+    function refresh(shop) {
+        return db.transaction(async (tx) => {
+            const found = await row(tx, shop, true);
+            if (found === null || found.uninstalled_at !== null)
+                return null;
+            const token = freshToken(found);
+            if (token !== null)
+                return token;
+            const { refresh_token: refreshToken, refresh_expires_at: refreshExpires } = found;
+            if (refreshToken === null || refreshExpires === null)
+                return null;
+            if (refreshExpires.getTime() <= now().getTime()) {
+                await clearTokens(tx, shop);
+                return null;
+            }
+            const answer = await api.refresh(shop, open(key, refreshToken, place(shop, 'refresh')));
+            switch (answer.kind) {
+                case 'tokens':
+                    await storeTokens(tx, shop, answer.tokens);
+                    return answer.tokens.accessToken;
+                case 'invalid':
+                    log.warn('shopify: the refresh token of a shop no longer works', { shop });
+                    await clearTokens(tx, shop);
+                    return null;
+                case 'failed':
+                    throw new Error(`shopify: refreshing the token of ${shop} failed: ${answer.reason}`);
+            }
+        });
+    }
+    /** A working access token: the fresh one without a lock, else one refresh at a time. */
+    async function accessToken(shop) {
+        const found = await row(db, shop);
+        if (found === null || found.uninstalled_at !== null)
+            return null;
+        const token = freshToken(found);
+        if (token !== null)
+            return token;
+        const running = refreshing.get(shop);
+        if (running !== undefined)
+            return running;
+        const started = refresh(shop).finally(() => refreshing.delete(shop));
+        refreshing.set(shop, started);
+        return started;
+    }
+    async function remember(q, shop, info) {
+        await q.query('UPDATE baukasten.shops SET email = $2, development = $3 WHERE domain = $1', [
+            shop,
+            info.email,
+            info.development
+        ]);
+    }
+    /**
+     * Asks Shopify what it says of the shop now and takes it; null while the app has no token that
+     * works, when the shop keeps what Shopify said last.
+     */
+    async function askInfo(q, shop) {
+        const token = await accessToken(shop);
+        if (token === null)
+            return null;
+        const info = await api.shopInfo(shop, token);
+        if (info !== null)
+            await remember(q, shop, info);
+        return info;
+    }
+    async function install(shop, tokens, info) {
+        await db.transaction(async (tx) => {
+            // Two first requests of a new shop at once install it once: the second waits here and finds
+            // the first.
+            await tx.query('SELECT pg_advisory_xact_lock(hashtext($1))', [`shopify:${shop}`]);
+            const found = await row(tx, shop, true);
+            if (found !== null && found.uninstalled_at === null) {
+                await remember(tx, shop, info);
+                await tx.query('UPDATE baukasten.shops SET exchanged_at = $2 WHERE domain = $1', [
+                    shop,
+                    now()
+                ]);
+                await storeTokens(tx, shop, tokens);
+                return;
+            }
+            await tx.query(`INSERT INTO baukasten.shops (domain, shop_id, app_id, email, development, scope,
+					installed_at, exchanged_at)
+				 VALUES ($1, $2, $3, $4, $5, $6, $7, $7)
+				 ON CONFLICT (domain) DO UPDATE SET shop_id = EXCLUDED.shop_id,
+					app_id = EXCLUDED.app_id, email = EXCLUDED.email, development = EXCLUDED.development,
+					installed_at = EXCLUDED.installed_at, exchanged_at = EXCLUDED.exchanged_at,
+					uninstalled_at = NULL, plan_handles = '{}', plan_trial_ends_at = NULL,
+					plan_checked_at = NULL`, [shop, info.shopId, info.appId, info.email, info.development, tokens.scope, now()]);
+            await storeTokens(tx, shop, tokens);
+            log.info('shopify: a shop installed the app', {
+                shop,
+                development: info.development,
+                again: found !== null
+            });
+        });
+    }
+    async function exchange(shop, idToken) {
+        let tokens;
+        let info;
+        // Shopify that does not answer, or not as it should, lets the shop not in for now; a failure of
+        // the database is the app's own and goes up.
+        try {
+            const answer = await api.exchange(shop, idToken);
+            if (answer.kind !== 'tokens')
+                return answer;
+            tokens = answer.tokens;
+            info = await api.shopInfo(shop, tokens.accessToken);
+        }
+        catch (error) {
+            log.warn('shopify: the token exchange of a shop failed', { shop, error });
+            return { kind: 'failed', reason: error instanceof Error ? error.message : String(error) };
+        }
+        if (info === null)
+            return { kind: 'failed', reason: 'the new token did not work' };
+        await install(shop, tokens, info);
+        return { kind: 'in' };
+    }
+    function planOf(handles, trialEndsAt) {
+        if (handles.length === 0)
+            return { kind: 'none' };
+        const known = deps.plans.find((plan) => handles.includes(plan.handle));
+        if (known === undefined) {
+            log.error('shopify: a subscription without a plan of the app; its plans in baukasten.config.ts differ from the Partner Dashboard', { handles });
+            return { kind: 'none' };
+        }
+        return { kind: 'active', handle: known.handle, trialEndsAt };
+    }
+    async function ask(found) {
+        const subscription = await api.subscription(found.app_id, found.shop_id);
+        const handles = subscription.kind === 'active' ? subscription.handles : [];
+        const trialEndsAt = subscription.kind === 'active' ? subscription.trialEndsAt : null;
+        await db.query(`UPDATE baukasten.shops SET plan_handles = $2, plan_trial_ends_at = $3, plan_checked_at = $4
+			 WHERE domain = $1`, [found.domain, handles, trialEndsAt, now()]);
+        // What Shopify says of the shop comes along, but never keeps the merchant out of the app: a
+        // failure keeps what it said last, in the log.
+        try {
+            await askInfo(db, found.domain);
+        }
+        catch (error) {
+            log.warn('shopify: what Shopify says of a shop could not be asked again', {
+                shop: found.domain,
+                error
+            });
+        }
+        return planOf(handles, trialEndsAt);
+    }
+    return {
+        async enter(shop, idToken) {
+            const found = await row(db, shop);
+            if (found !== null &&
+                found.uninstalled_at === null &&
+                scopesCover(found.scope, deps.scopes)) {
+                try {
+                    if ((await accessToken(shop)) !== null)
+                        return { kind: 'in' };
+                }
+                catch (error) {
+                    log.error('shopify: refreshing a token failed; trying the token exchange', {
+                        shop,
+                        error
+                    });
+                }
+            }
+            return exchange(shop, idToken);
+        },
+        accessToken,
+        forgetTokens: (shop, failed) => db.transaction(async (tx) => {
+            const found = await row(tx, shop, true);
+            const access = found?.access_token ?? null;
+            if (access === null || open(key, access, place(shop, 'access')) !== failed)
+                return false;
+            await clearTokens(tx, shop);
+            return true;
+        }),
+        async plan(shop, freshly) {
+            const found = await row(db, shop);
+            if (found === null || found.uninstalled_at !== null)
+                return { kind: 'none' };
+            const checked = found.plan_checked_at;
+            if (!freshly && checked !== null && now().getTime() - checked.getTime() < PLAN_FRESH_MS) {
+                return planOf(found.plan_handles, found.plan_trial_ends_at);
+            }
+            return ask(found);
+        },
+        async uninstall(tx, shop, triggeredAt) {
+            const ended = await tx.query(`UPDATE baukasten.shops SET uninstalled_at = $2, access_token = NULL,
+					access_expires_at = NULL, refresh_token = NULL, refresh_expires_at = NULL,
+					plan_handles = '{}', plan_trial_ends_at = NULL, plan_checked_at = NULL
+				 WHERE domain = $1 AND uninstalled_at IS NULL AND exchanged_at <= $3
+				 RETURNING domain`, [shop, now(), triggeredAt]);
+            return ended.length > 0;
+        },
+        async redact(tx, shop) {
+            await tx.query('DELETE FROM baukasten.shops WHERE domain = $1', [shop]);
+        },
+        async email(q, shop) {
+            const found = await row(q, shop);
+            if (found === null)
+                return null;
+            const info = await askInfo(q, shop);
+            return info === null ? found.email : info.email;
+        },
+        async anyInstalled() {
+            const [found] = await db.query('SELECT app_id, shop_id FROM baukasten.shops WHERE uninstalled_at IS NULL LIMIT 1');
+            return found === undefined ? null : { appId: found.app_id, shopId: found.shop_id };
+        }
+    };
+}

package/dist/shopify/sveltekit.d.ts

@@ -0,0 +1,19 @@
+export declare const SHOPIFY_SVELTEKIT_OPTIONS: {
+    csrf: {
+        trustedOrigins: string[];
+    };
+    csp: {
+        mode: "auto";
+        directives: {
+            'default-src': "self"[];
+            'script-src': ("https://cdn.shopify.com/shopifycloud/" | "self")[];
+            'style-src': ("https://cdn.shopify.com" | "self" | "unsafe-inline")[];
+            'img-src': ("https://cdn.shopify.com" | "data:" | "self")[];
+            'font-src': ("https://cdn.shopify.com" | "self")[];
+            'connect-src': ("https://cdn.shopify.com" | "self")[];
+            'form-action': "self"[];
+            'base-uri': "self"[];
+            'object-src': "none"[];
+        };
+    };
+};

package/dist/shopify/sveltekit.js

@@ -0,0 +1,18 @@
+import { SHOPIFY_CDN, SHOPIFY_SCRIPTS } from './constants.js';
+export const SHOPIFY_SVELTEKIT_OPTIONS = {
+    csrf: { trustedOrigins: ['*'] },
+    csp: {
+        mode: 'auto',
+        directives: {
+            'default-src': ['self'],
+            'script-src': ['self', SHOPIFY_SCRIPTS],
+            'style-src': ['self', 'unsafe-inline', SHOPIFY_CDN],
+            'img-src': ['self', 'data:', SHOPIFY_CDN],
+            'font-src': ['self', SHOPIFY_CDN],
+            'connect-src': ['self', SHOPIFY_CDN],
+            'form-action': ['self'],
+            'base-uri': ['self'],
+            'object-src': ['none']
+        }
+    }
+};

package/dist/shopify/texts.d.ts

@@ -0,0 +1,28 @@
+import type { Language } from '../product.js';
+export interface ShopifyTexts {
+    /** The page of an address of the app opened outside the admin. */
+    outside: {
+        title: (name: string) => string;
+        text: (name: string) => string;
+        privacy: string;
+    };
+    /** The page when Shopify does not answer as it should, or the app is not linked yet. */
+    unavailable: {
+        title: string;
+        text: string;
+    };
+    dataRequest: {
+        subject: (name: string) => string;
+        text: (request: {
+            name: string;
+            shop: string;
+            customer: {
+                id: string;
+                email: string | null;
+                phone: string | null;
+            };
+            data: string | null;
+        }) => string;
+    };
+}
+export declare const SHOPIFY_TEXTS: Record<Language, ShopifyTexts>;