@cloudcannon/sdk 0.0.0

package/dist/index.d.ts

@@ -0,0 +1,77 @@
+import type { components, operations, paths } from './schema.ts';
+import { InboxClient } from './src/inbox.ts';
+import { OrgClient } from './src/org.ts';
+import { type BuildConfiguration, SiteClient } from './src/site.ts';
+import { SiteInboxClient } from './src/site-inbox.ts';
+export type { BuildConfiguration };
+export type Provider = operations['Providers_Repositories']['parameters']['path']['provider'];
+export type Site = components['schemas']['SiteBlueprint'];
+export type Org = components['schemas']['OrgBlueprintFull'];
+export type Build = components['schemas']['BuildBlueprint'];
+export type Sync = components['schemas']['SyncBlueprint'];
+export type SiteScan = components['schemas']['SiteScannerBlueprint'];
+export type SiteInbox = components['schemas']['SiteInboxBlueprint'];
+export type SiteDam = components['schemas']['SiteDamBlueprint'];
+export type FormSubmission = components['schemas']['FormHookBlueprint'];
+export type Inbox = components['schemas']['InboxBlueprint'];
+export type Dam = components['schemas']['DamBlueprint'];
+export type ProviderDetails = {
+    provider: Provider;
+    repository: string;
+    branch: string;
+};
+type ParamToString<S extends string> = S extends `${infer A}/{${string}}/${infer B}` ? `${A}/${string}/${ParamToString<B>}` : S extends `${infer A}/{${string}}` ? `${A}/${string}` : S;
+type StripPrefix<S extends string> = S extends `/api/v0${infer Rest}` ? Rest : never;
+type RequestBody<T> = T extends {
+    requestBody: {
+        content: {
+            'application/json': infer B;
+        };
+    };
+} ? B : never;
+type RequestParams<T> = T extends {
+    parameters: infer P;
+} ? P : never;
+type ResponseMixin<S, R> = {
+    status: S;
+    json: R extends {
+        content: {
+            'application/json': infer J;
+        };
+    } ? () => Promise<J> : never;
+};
+type RequestMixin<M, Op> = {
+    method?: M;
+    body?: RequestBody<Op>;
+};
+type APIResponse<Op> = Op extends {
+    responses: infer R;
+} ? {
+    [status in keyof R]: Omit<Response, keyof ResponseMixin<status, R[status]>> & ResponseMixin<status, R[status]>;
+}[keyof R] : never;
+type Split<S extends string> = S extends `${infer Head}/${infer Tail}` ? [Head, ...Split<Tail>] : [S];
+type SegmentMatch<A extends string[], B extends string[]> = A['length'] extends B['length'] ? A extends [infer AH extends string, ...infer AT extends string[]] ? B extends [infer BH extends string, ...infer BT extends string[]] ? AH extends BH ? SegmentMatch<AT, BT> : never : never : true : never;
+type MatchURL<M extends keyof paths[keyof paths], U extends string> = {
+    [K in keyof paths]: [
+        SegmentMatch<Split<U>, Split<ParamToString<StripPrefix<K & string>>>>
+    ] extends [never] ? never : RequestParams<paths[K][M]> extends never ? never : paths[K];
+}[keyof paths];
+type ValidURL<M extends keyof paths[keyof paths], U extends string> = MatchURL<M, U> extends never ? {
+    [K in keyof paths]: RequestParams<paths[K][M]> extends never ? never : StripPrefix<K>;
+}[keyof paths] : U;
+export type CloudCannonClientConfig = {
+    key: string;
+    apiOrigin?: string;
+    getCustomAuthHeaders?: () => Record<string, string>;
+};
+export default class CloudCannonClient {
+    #private;
+    constructor(config: CloudCannonClientConfig);
+    getAuthHeaders(): Record<string, string>;
+    fetch<const U extends string, const M extends Uppercase<keyof paths[keyof paths]> = 'GET'>(url: ValidURL<Lowercase<M>, U>, options?: Omit<RequestInit, keyof RequestMixin<M, MatchURL<Lowercase<M>, U>[Lowercase<M>]>> & RequestMixin<M, MatchURL<Lowercase<M>, U>[Lowercase<M>]>): Promise<APIResponse<MatchURL<Lowercase<M>, U>[Lowercase<M>]>>;
+    org(uuid: string): OrgClient;
+    site(uuid: string): SiteClient;
+    inbox(uuid: string): InboxClient;
+    siteInbox(uuid: string): SiteInboxClient;
+    orgs(): Promise<Org[]>;
+}

package/dist/index.js

@@ -0,0 +1,60 @@
+import { InboxClient } from "./src/inbox.js";
+import { OrgClient } from "./src/org.js";
+import { SiteClient } from "./src/site.js";
+import { SiteInboxClient } from "./src/site-inbox.js";
+export default class CloudCannonClient {
+    #apiKey;
+    #appDomain;
+    #getCustomAuthHeaders;
+    constructor(config) {
+        this.#apiKey = config.key;
+        this.#appDomain = config.apiOrigin ?? 'app.cloudcannon.com';
+        this.#getCustomAuthHeaders = config.getCustomAuthHeaders;
+    }
+    getAuthHeaders() {
+        if (this.#getCustomAuthHeaders) {
+            return {
+                ...this.#getCustomAuthHeaders(),
+            };
+        }
+        return {
+            'X-API-KEY': `${this.#apiKey}`,
+        };
+    }
+    async fetch(url, options) {
+        const requestInit = {
+            ...options,
+            headers: {
+                ...this.getAuthHeaders(),
+                'Content-Type': 'application/json',
+                ...options?.headers,
+            },
+        };
+        if (options?.body) {
+            if (typeof options?.body !== 'string') {
+                requestInit.body = JSON.stringify(options.body);
+            }
+            else {
+                requestInit.body = options.body;
+            }
+        }
+        return fetch(`https://${this.#appDomain}/api/v0${url}`, requestInit);
+    }
+    org(uuid) {
+        return new OrgClient(uuid, this);
+    }
+    site(uuid) {
+        return new SiteClient(uuid, this);
+    }
+    inbox(uuid) {
+        return new InboxClient(uuid, this);
+    }
+    siteInbox(uuid) {
+        return new SiteInboxClient(uuid, this);
+    }
+    async orgs() {
+        const resp = await this.fetch('/orgs');
+        const orgs = await resp.json();
+        return orgs;
+    }
+}