@cloudcannon/sdk 0.0.2 → 0.0.4

package/dist/src/backup.d.ts

@@ -0,0 +1,6 @@
+import type CloudCannonClient from '../index.ts';
+export declare class BackupClient {
+    #private;
+    constructor(uuid: string, client: CloudCannonClient);
+    download(): Promise<Response>;
+}

package/dist/src/backup.js

@@ -0,0 +1,15 @@
+export class BackupClient {
+    #uuid;
+    #client;
+    constructor(uuid, client) {
+        this.#uuid = uuid;
+        this.#client = client;
+    }
+    async download() {
+        const resp = await this.#client.fetch(`/site-archives/${this.#uuid}/download`);
+        if (resp.status === 401 || resp.status === 403) {
+            throw new Error('Error downloading backup. Permission denied');
+        }
+        return resp;
+    }
+}

package/dist/src/helpers/query.d.ts

@@ -0,0 +1,28 @@
+export type PaginationOptions = {
+    page?: number;
+    items?: number;
+};
+export type SortingOptions<Op> = Op extends {
+    parameters: {
+        query?: infer Q;
+    };
+} ? Pick<NonNullable<Q>, Extract<keyof NonNullable<Q>, 'sort_attribute' | 'sort_direction'>> : never;
+export type FilterOptions<Op> = Op extends {
+    parameters: {
+        query?: infer Q;
+    };
+} ? {
+    filters?: Omit<NonNullable<Q>, 'page' | 'items' | 'sort_attribute' | 'sort_direction'>;
+} : never;
+export type PaginatedResponse<T> = {
+    items: T[];
+    current_page?: number;
+    total_items?: number;
+    total_pages?: number;
+};
+export declare function buildQuery(options?: PaginationOptions & {
+    sort_attribute?: string;
+    sort_direction?: 'ASC' | 'DESC';
+    filters?: Record<string, unknown>;
+}): string;
+export declare function paginatedResponse<T>(items: T[], headers: Headers): PaginatedResponse<T>;

package/dist/src/helpers/query.js

@@ -0,0 +1,34 @@
+export function buildQuery(options = {}) {
+    const params = new URLSearchParams();
+    if (options.page !== undefined)
+        params.set('page', String(options.page));
+    if (options.items !== undefined)
+        params.set('items', String(options.items));
+    if (options.sort_attribute !== undefined)
+        params.set('sort_attribute', options.sort_attribute);
+    if (options.sort_direction !== undefined)
+        params.set('sort_direction', options.sort_direction);
+    if (options.filters) {
+        for (const [key, value] of Object.entries(options.filters)) {
+            if (value !== undefined) {
+                params.set(key, String(value));
+            }
+        }
+    }
+    return params.toString();
+}
+export function paginatedResponse(items, headers) {
+    const parse = (name) => {
+        const value = headers.get(name);
+        if (value === null)
+            return undefined;
+        const parsed = Number(value);
+        return Number.isFinite(parsed) ? parsed : undefined;
+    };
+    return {
+        items,
+        current_page: parse('current_page'),
+        total_items: parse('total_items'),
+        total_pages: parse('total_pages'),
+    };
+}

package/dist/src/inbox.d.ts

@@ -1,7 +1,10 @@
 import type CloudCannonClient from '../index.ts';
 import type { FormSubmission } from '../index.ts';
+import type { operations } from '../schema.js';
+import { type FilterOptions, type PaginatedResponse, type PaginationOptions, type SortingOptions } from './helpers/query.ts';
+export type ListInboxSubmissionsOptions = PaginationOptions & SortingOptions<operations['Inbox Form Hooks_Index']> & FilterOptions<operations['Inbox Form Hooks_Index']>;
 export declare class InboxClient {
     #private;
     constructor(uuid: string, client: CloudCannonClient);
-    getSubmissions(): Promise<FormSubmission[]>;
+    getSubmissions(options?: ListInboxSubmissionsOptions): Promise<PaginatedResponse<FormSubmission>>;
 }

package/dist/src/inbox.js

@@ -1,3 +1,4 @@
+import { buildQuery, paginatedResponse, } from "./helpers/query.js";
 export class InboxClient {
     #uuid;
     #client;
@@ -5,12 +6,13 @@ export class InboxClient {
         this.#uuid = uuid;
         this.#client = client;
     }
-    async getSubmissions() {
-        const resp = await this.#client.fetch(`/inboxes/${this.#uuid}/form-hooks`);
+    async getSubmissions(options = {}) {
+        const query = buildQuery(options);
+        const resp = await this.#client.fetch(`/inboxes/${this.#uuid}/form-hooks?${query}`);
         if (resp.status === 401 || resp.status === 403) {
             throw new Error('Error fetching submissions. Permission denied');
         }
         const submissions = await resp.json();
-        return submissions;
+        return paginatedResponse(submissions, resp.headers);
     }
 }

package/dist/src/org.d.ts

@@ -1,22 +1,26 @@
 import type CloudCannonClient from '../index.ts';
 import type { Dam, Inbox, Org, Provider, ProviderDetails, Site } from '../index.ts';
 import type { operations } from '../schema.js';
+import { type FilterOptions, type PaginatedResponse, type PaginationOptions, type SortingOptions } from './helpers/query.ts';
 export interface ConnectSiteOptions extends ProviderDetails {
     folder?: string;
 }
 export type Repository = operations['Providers_Repositories']['responses']['200']['content']['application/json'][number];
+export type ListOrgSitesOptions = PaginationOptions & SortingOptions<operations['Sites_Index']> & FilterOptions<operations['Sites_Index']>;
+export type ListOrgInboxesOptions = PaginationOptions & SortingOptions<operations['Organization Inboxes_Index']> & FilterOptions<operations['Organization Inboxes_Index']>;
+export type ListOrgDamsOptions = PaginationOptions & SortingOptions<operations['DAMs_Index']> & FilterOptions<operations['DAMs_Index']>;
 export type CreateInboxOptions = operations['Organization Inboxes_Create']['requestBody']['content']['application/json'];
 export type CreateDamOptions = operations['DAMs_Create']['requestBody']['content']['application/json'];
 export declare class OrgClient {
     #private;
     constructor(uuid: string, client: CloudCannonClient);
-    sites(): Promise<Site[]>;
+    sites(options?: ListOrgSitesOptions): Promise<PaginatedResponse<Site>>;
     createSite(name: string, stableDomain?: string): Promise<Site>;
     connectSite(name: string, providerDetails: ConnectSiteOptions, stableDomain?: string): Promise<Site>;
     get(): Promise<Org>;
-    getInboxes(): Promise<Inbox[]>;
+    getInboxes(options?: ListOrgInboxesOptions): Promise<PaginatedResponse<Inbox>>;
     createInbox(body: CreateInboxOptions): Promise<Inbox>;
-    getDams(): Promise<Dam[]>;
+    getDams(options?: ListOrgDamsOptions): Promise<PaginatedResponse<Dam>>;
     createDam(body: CreateDamOptions): Promise<Dam>;
     getRepositories(provider: Provider): Promise<Repository[]>;
 }

package/dist/src/org.js

@@ -1,4 +1,5 @@
 import { ApiError } from "./errors.js";
+import { buildQuery, paginatedResponse, } from "./helpers/query.js";
 export class OrgClient {
     #uuid;
     #client;
@@ -6,13 +7,14 @@ export class OrgClient {
         this.#uuid = uuid;
         this.#client = client;
     }
-    async sites() {
-        const resp = await this.#client.fetch(`/orgs/${this.#uuid}/sites`);
+    async sites(options = {}) {
+        const query = buildQuery(options);
+        const resp = await this.#client.fetch(`/orgs/${this.#uuid}/sites?${query}`);
         if (resp.status === 401 || resp.status === 403) {
             throw new Error('Error fetching sites. Permission denied');
         }
         const sites = await resp.json();
-        return sites;
+        return paginatedResponse(sites, resp.headers);
     }
     async createSite(name, stableDomain) {
         const resp = await this.#client.fetch(`/orgs/${this.#uuid}/sites`, {
@@ -63,13 +65,14 @@ export class OrgClient {
         const org = await resp.json();
         return org;
     }
-    async getInboxes() {
-        const resp = await this.#client.fetch(`/orgs/${this.#uuid}/inboxes`);
+    async getInboxes(options = {}) {
+        const query = buildQuery(options);
+        const resp = await this.#client.fetch(`/orgs/${this.#uuid}/inboxes?${query}`);
         if (resp.status === 403) {
             throw new Error('Error fetching inboxes. Permission denied');
         }
         const inboxes = await resp.json();
-        return inboxes;
+        return paginatedResponse(inboxes, resp.headers);
     }
     async createInbox(body) {
         const resp = await this.#client.fetch(`/orgs/${this.#uuid}/inboxes`, {
@@ -86,10 +89,11 @@ export class OrgClient {
         const inbox = await resp.json();
         return inbox;
     }
-    async getDams() {
-        const resp = await this.#client.fetch(`/orgs/${this.#uuid}/dams`);
+    async getDams(options = {}) {
+        const query = buildQuery(options);
+        const resp = await this.#client.fetch(`/orgs/${this.#uuid}/dams?${query}`);
         const dams = await resp.json();
-        return dams;
+        return paginatedResponse(dams, resp.headers);
     }
     async createDam(body) {
         const resp = await this.#client.fetch(`/orgs/${this.#uuid}/dams`, {

package/dist/src/site.d.ts

@@ -1,6 +1,7 @@
 import type CloudCannonClient from '../index.ts';
-import type { Build, EditingSession, ProviderDetails, Site, SiteDam, SiteInbox, SiteScan, Sync } from '../index.ts';
+import type { Backup, Build, EditingSession, ProviderDetails, Site, SiteDam, SiteInbox, SiteScan, Sync } from '../index.ts';
 import type { operations } from '../schema.js';
+import { type FilterOptions, type PaginatedResponse, type PaginationOptions, type SortingOptions } from './helpers/query.ts';
 export type BuildConfiguration = Partial<Omit<operations['Sites_UpdateBuild']['requestBody']['content']['application/json'], 'build_configuration'>> & {
     compile?: {
         install_command?: string;
@@ -22,6 +23,10 @@ export type BuildConfiguration = Partial<Omit<operations['Sites_UpdateBuild']['r
 };
 export type UpdateSiteOptions = operations['Sites_Update']['requestBody']['content']['application/json'];
 export type CopySiteOptions = operations['Sites_Copy']['requestBody']['content']['application/json'];
+export type ListSiteBuildsOptions = PaginationOptions & SortingOptions<operations['Builds_Index']> & FilterOptions<operations['Builds_Index']>;
+export type ListSiteBackupsOptions = PaginationOptions & SortingOptions<operations['Backups_Index']> & FilterOptions<operations['Backups_Index']>;
+export type ListSiteSyncsOptions = PaginationOptions & SortingOptions<operations['Syncs_Index']> & FilterOptions<operations['Syncs_Index']>;
+export type CreateBackupOptions = operations['Backups_Create']['requestBody']['content']['application/json'];
 export type ConnectInboxOptions = operations['Site Inboxes_Create']['requestBody']['content']['application/json'];
 export type ConnectDamOptions = operations['Dams_Create']['requestBody']['content']['application/json'];
 export type FileListing = operations['Files_Index']['responses']['200']['content']['application/json'][number];
@@ -37,11 +42,15 @@ export declare class SiteClient {
     delete(): Promise<void>;
     copy(body: CopySiteOptions): Promise<Site>;
     updateBuildConfig(options: BuildConfiguration): Promise<Site>;
-    getBuilds(): Promise<Build[]>;
+    getBuilds(options?: ListSiteBuildsOptions): Promise<PaginatedResponse<Build>>;
     rebuild(): Promise<void>;
+    listBackups(options?: ListSiteBackupsOptions): Promise<PaginatedResponse<Backup>>;
+    createBackup(body?: CreateBackupOptions): Promise<{
+        socket_message_id?: string;
+    }>;
     listFiles(): Promise<FileListing[]>;
     getFile(path: string): Promise<Response>;
-    getSyncs(): Promise<Sync[]>;
+    getSyncs(options?: ListSiteSyncsOptions): Promise<PaginatedResponse<Sync>>;
     getScan(): Promise<SiteScan>;
     getScreenshotHashes(): Promise<Record<string, string>>;
     getScreenshot(device: 'desktop' | 'mobile', path: string): Promise<Response>;
@@ -58,4 +67,5 @@ export declare class SiteClient {
     createEditingSession(): Promise<EditingSession>;
     getLatestEditingSession(): Promise<EditingSession>;
     uploadFile(path: string, content: BlobPart, options?: UploadFileOptions): Promise<void>;
+    triggerPull(): Promise<void>;
 }

package/dist/src/site.js

@@ -1,4 +1,5 @@
 import { ApiError } from "./errors.js";
+import { buildQuery, paginatedResponse, } from "./helpers/query.js";
 export class SiteClient {
     #uuid;
     #client;
@@ -70,13 +71,14 @@ export class SiteClient {
         const site = await resp.json();
         return site;
     }
-    async getBuilds() {
-        const resp = await this.#client.fetch(`/sites/${this.#uuid}/builds`);
+    async getBuilds(options = {}) {
+        const query = buildQuery(options);
+        const resp = await this.#client.fetch(`/sites/${this.#uuid}/builds?${query}`);
         if (resp.status === 401 || resp.status === 403) {
             throw new Error('Error fetching builds. Permission denied');
         }
         const builds = await resp.json();
-        return builds;
+        return paginatedResponse(builds, resp.headers);
     }
     async rebuild() {
         const resp = await this.#client.fetch(`/sites/${this.#uuid}/builds`, {
@@ -86,6 +88,30 @@ export class SiteClient {
             throw new Error('Error creating build. Permission denied');
         }
     }
+    async listBackups(options = {}) {
+        const query = buildQuery(options);
+        const resp = await this.#client.fetch(`/sites/${this.#uuid}/archives?${query}`);
+        if (resp.status === 401) {
+            throw new Error('Error fetching backups. Permission denied');
+        }
+        const items = await resp.json();
+        return paginatedResponse(items, resp.headers);
+    }
+    async createBackup(body = {}) {
+        const resp = await this.#client.fetch(`/sites/${this.#uuid}/archives`, {
+            method: 'POST',
+            body,
+        });
+        if (resp.status === 401) {
+            throw new Error('Error creating backup. Permission denied');
+        }
+        if (resp.status === 422) {
+            const errorResp = await resp.json();
+            throw new ApiError('Error creating backup. Invalid request', errorResp.errors, `/sites/${this.#uuid}/archives`, { method: 'POST', body }, resp.status);
+        }
+        const result = await resp.json();
+        return result;
+    }
     async listFiles() {
         const resp = await this.#client.fetch(`/sites/${this.#uuid}/files`);
         if (resp.status === 401) {
@@ -112,13 +138,14 @@ export class SiteClient {
         }
         return resp;
     }
-    async getSyncs() {
-        const resp = await this.#client.fetch(`/sites/${this.#uuid}/syncs`);
+    async getSyncs(options = {}) {
+        const query = buildQuery(options);
+        const resp = await this.#client.fetch(`/sites/${this.#uuid}/syncs?${query}`);
         if (resp.status === 401) {
             throw new Error('Error fetching syncs. Permission denied');
         }
         const syncs = await resp.json();
-        return syncs;
+        return paginatedResponse(syncs, resp.headers);
     }
     async getScan() {
         const resp = await this.#client.fetch(`/sites/${this.#uuid}/scans`);
@@ -342,4 +369,13 @@ export class SiteClient {
             previous_content_hash: contentHash,
         });
     }
+    async triggerPull() {
+        const resp = await this.#client.fetch(`/sites/${this.#uuid}/providers/sync`, {
+            method: 'POST',
+        });
+        if (resp.status === 422) {
+            const errorResp = await resp.json();
+            throw new ApiError('Error triggering pull on site. Invalid request', errorResp.errors, `/sites/${this.#uuid}/providers/sync`, { method: 'POST' }, resp.status);
+        }
+    }
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@cloudcannon/sdk",
   "type": "module",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "description": "REST API client for the CloudCannon CMS.",
   "keywords": [
     "cloudcannon",