@tollwyn/baukasten 0.0.2 → 1.2.3

package/dist/server/openapi.js

@@ -0,0 +1,173 @@
+import { API_PATHS } from './endpoints.js';
+const ref = (name) => ({ $ref: `#/components/schemas/${name}` });
+const json = (schema) => ({ 'application/json': { schema } });
+export function openApiPart(origin, messages) {
+    const o = messages.openApi;
+    const error = (description) => ({ description, content: json(ref('Error')) });
+    return {
+        paths: {
+            [API_PATHS.signup]: {
+                post: {
+                    operationId: 'signUp',
+                    summary: o.signup,
+                    security: [],
+                    requestBody: {
+                        required: true,
+                        content: json({
+                            type: 'object',
+                            required: ['email', 'accept_terms', 'acting_for_business'],
+                            properties: {
+                                email: { type: 'string', format: 'email', maxLength: 254, description: o.email },
+                                accept_terms: {
+                                    type: 'boolean',
+                                    const: true,
+                                    description: `${o.acceptTerms} ${origin}/terms`
+                                },
+                                acting_for_business: {
+                                    type: 'boolean',
+                                    const: true,
+                                    description: o.actingForBusiness
+                                },
+                                via: {
+                                    type: 'string',
+                                    maxLength: 32,
+                                    pattern: '^[a-z0-9]+(-[a-z0-9]+)*$',
+                                    description: o.via
+                                }
+                            }
+                        })
+                    },
+                    responses: {
+                        '201': {
+                            description: o.signupCreated,
+                            content: json({
+                                type: 'object',
+                                required: ['api_key', 'account'],
+                                properties: { api_key: { type: 'string' }, account: ref('Account') }
+                            })
+                        },
+                        '400': error(o.errors.invalidJson),
+                        '403': error(o.errors.forbidden),
+                        '409': error(o.errors.emailTaken),
+                        '422': error(o.errors.invalidRequest),
+                        '429': error(o.errors.rateLimited)
+                    }
+                }
+            },
+            [API_PATHS.account]: {
+                get: {
+                    operationId: 'getAccount',
+                    summary: o.account,
+                    security: [{ apiKey: [] }],
+                    responses: {
+                        '200': { description: o.account, content: json(ref('Account')) },
+                        '401': error(o.errors.unauthorized),
+                        '429': error(o.errors.rateLimited)
+                    }
+                }
+            },
+            [API_PATHS.checkout]: {
+                post: {
+                    operationId: 'openCheckout',
+                    summary: o.checkout,
+                    description: o.checkoutBody,
+                    security: [{ apiKey: [] }],
+                    requestBody: {
+                        required: true,
+                        content: json({
+                            type: 'object',
+                            required: ['price'],
+                            properties: {
+                                price: { type: 'string', description: o.price },
+                                quantity: { type: 'integer', minimum: 1, description: o.quantity }
+                            }
+                        })
+                    },
+                    responses: {
+                        '200': { description: o.url, content: json(ref('Url')) },
+                        '400': error(o.errors.invalidJson),
+                        '401': error(o.errors.unauthorized),
+                        '409': error(o.errors.subscribed),
+                        '422': error(o.errors.invalidRequest),
+                        '429': error(o.errors.rateLimited),
+                        '503': error(o.errors.notConfigured)
+                    }
+                }
+            },
+            [API_PATHS.portal]: {
+                post: {
+                    operationId: 'openPortal',
+                    summary: o.portal,
+                    security: [{ apiKey: [] }],
+                    responses: {
+                        '200': { description: o.url, content: json(ref('Url')) },
+                        '401': error(o.errors.unauthorized),
+                        '409': error(o.errors.noCustomer),
+                        '429': error(o.errors.rateLimited),
+                        '503': error(o.errors.notConfigured)
+                    }
+                }
+            }
+        },
+        components: {
+            schemas: {
+                Error: {
+                    type: 'object',
+                    required: ['error'],
+                    properties: {
+                        error: {
+                            type: 'object',
+                            required: ['code', 'message'],
+                            properties: {
+                                code: { type: 'string' },
+                                message: { type: 'string' },
+                                details: {}
+                            }
+                        }
+                    }
+                },
+                Url: {
+                    type: 'object',
+                    required: ['url'],
+                    properties: { url: { type: 'string', format: 'uri', description: o.url } }
+                },
+                Account: {
+                    type: 'object',
+                    required: ['id', 'email', 'email_verified', 'created_at'],
+                    properties: {
+                        id: { type: 'string', format: 'uuid' },
+                        email: { type: 'string', format: 'email' },
+                        email_verified: { type: 'boolean' },
+                        created_at: { type: 'string', format: 'date-time' }
+                    }
+                }
+            },
+            securitySchemes: {
+                apiKey: { type: 'http', scheme: 'bearer', description: o.apiKey }
+            }
+        }
+    };
+}
+/**
+ * `document` with the part of the baukasten. The product's own paths use its security scheme
+ * `apiKey` and its schema `Error`; a name both define is an error, not an override.
+ */
+export function mergeOpenApi(document, part) {
+    const merge = (what, theirs, own) => {
+        const both = Object.keys(own ?? {}).filter((key) => key in theirs);
+        if (both.length > 0) {
+            throw new Error(`the OpenAPI document of the product defines ${what} of the baukasten: ${both.join(', ')}`);
+        }
+        return { ...theirs, ...own };
+    };
+    const components = document.components ?? {};
+    return {
+        ...document,
+        paths: merge('paths', part.paths, document.paths),
+        components: {
+            ...components,
+            schemas: merge('schemas', part.components.schemas, components.schemas),
+            securitySchemes: merge('security schemes', part.components.securitySchemes, components.securitySchemes)
+        }
+    };
+}

package/dist/server/pages.d.ts

@@ -0,0 +1,158 @@
+import { type RequestEvent } from '@sveltejs/kit';
+import type { Brand } from '../product.js';
+import type { AccountData, ConfirmData, FrameData, LegalData, LoginData, LogoutData, ResetData, SignupData, VerifyData } from '../ui/data.js';
+import { type Services } from './services.js';
+type LoadEvent = {
+    locals: App.Locals;
+    url: URL;
+};
+/** The marks of the product as the frame shows them: the picture of a shared link at its whole address. */
+export declare function frameBrand(brand: Brand | undefined, origin: string): FrameData['brand'];
+export type Pages = ReturnType<typeof createPages>;
+export declare function createPages(services: () => Services): {
+    layout: {
+        load: ({ locals, url }: LoadEvent) => {
+            frame: FrameData;
+        };
+    };
+    imprint: {
+        load: () => {
+            legal: LegalData;
+        };
+    };
+    privacy: {
+        load: () => {
+            legal: LegalData;
+        };
+    };
+    terms: {
+        load: () => {
+            legal: LegalData;
+        };
+    };
+    signup: {
+        load: ({ locals, url }: LoadEvent) => {
+            signup: SignupData;
+        };
+        actions: {
+            default: (event: RequestEvent) => Promise<import("@sveltejs/kit").ActionFailure<{
+                email: string;
+                error: string;
+            }>>;
+        };
+    };
+    login: {
+        load: ({ locals, url }: LoadEvent) => {
+            login: LoginData;
+        };
+        actions: {
+            default: (event: RequestEvent) => Promise<import("@sveltejs/kit").ActionFailure<{
+                email: string;
+                error: string;
+            }>>;
+        };
+    };
+    logout: {
+        load: ({ locals, url }: LoadEvent) => {
+            logout: LogoutData;
+        };
+        actions: {
+            default: ({ cookies }: RequestEvent) => Promise<never>;
+        };
+    };
+    forgotPassword: {
+        actions: {
+            default: (event: RequestEvent) => Promise<import("@sveltejs/kit").ActionFailure<{
+                email: string;
+                error: string;
+            }> | {
+                email: string;
+                sent: boolean;
+            }>;
+        };
+    };
+    resetPassword: {
+        load: ({ url }: LoadEvent) => Promise<{
+            reset: ResetData;
+        }>;
+        actions: {
+            default: (event: RequestEvent) => Promise<import("@sveltejs/kit").ActionFailure<{
+                error: string;
+            }>>;
+        };
+    };
+    /**
+     * The link of the mail opens a page with a button instead of confirming on GET, so that a mail
+     * scanner that opens links does not use it up. Confirming never logs into an account that has
+     * a password: whoever holds a mistyped address must not get in. An account from the API has
+     * none; it may set one here and is logged in.
+     */
+    verifyEmail: {
+        load: ({ locals, url }: LoadEvent) => Promise<{
+            verify: VerifyData;
+        }>;
+        actions: {
+            confirm: (event: RequestEvent) => Promise<import("@sveltejs/kit").ActionFailure<{
+                error: string;
+            }>>;
+            resend: (event: RequestEvent) => Promise<import("@sveltejs/kit").ActionFailure<{
+                error: string;
+            }> | {
+                resent: string;
+            }>;
+        };
+    };
+    confirmEmail: {
+        load: ({ url }: LoadEvent) => Promise<{
+            confirm: ConfirmData;
+        }>;
+        actions: {
+            default: (event: RequestEvent) => Promise<import("@sveltejs/kit").ActionFailure<{
+                error: string;
+            }>>;
+        };
+    };
+    account: {
+        load: (event: LoadEvent) => Promise<{
+            account: AccountData;
+        }>;
+        actions: {
+            createKey: (event: RequestEvent) => Promise<import("@sveltejs/kit").ActionFailure<{
+                action: "createKey";
+                error: string;
+            }> | {
+                action: "createKey";
+                key: string;
+            }>;
+            revokeKey: (event: RequestEvent) => Promise<{
+                action: "revokeKey";
+            }>;
+            changePassword: (event: RequestEvent) => Promise<import("@sveltejs/kit").ActionFailure<{
+                action: "changePassword";
+                error: string;
+            }> | {
+                action: "changePassword";
+                done: boolean;
+            }>;
+            changeEmail: (event: RequestEvent) => Promise<import("@sveltejs/kit").ActionFailure<{
+                action: "changeEmail";
+                email: string;
+                error: string;
+            }> | {
+                action: "changeEmail";
+                email: string;
+                sentTo: string;
+            }>;
+            /**
+             * Only a customer has a portal; opening it must not make one, which with the live key
+             * makes the account live.
+             */
+            portal: (event: RequestEvent) => Promise<never>;
+            delete: (event: RequestEvent) => Promise<import("@sveltejs/kit").ActionFailure<{
+                action: "delete";
+                error: string;
+            }>>;
+        };
+    };
+};
+export {};