@cloudcannon/sdk 0.0.1 → 0.0.3

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/build.d.ts

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

package/dist/src/build.js

@@ -0,0 +1,15 @@
+export class BuildClient {
+    #uuid;
+    #client;
+    constructor(uuid, client) {
+        this.#uuid = uuid;
+        this.#client = client;
+    }
+    async get() {
+        const resp = await this.#client.fetch(`/builds/${this.#uuid}`);
+        if (resp.status === 401 || resp.status === 403) {
+            throw new Error('Error fetching build. Permission denied');
+        }
+        return resp;
+    }
+}

package/dist/src/editing-session-file.d.ts

@@ -0,0 +1,13 @@
+import type CloudCannonClient from '../index.ts';
+import type { EditingSessionFile, EditingSessionFileContribution } from '../index.ts';
+import type { operations } from '../schema.js';
+export type CreateContributionOptions = operations['Editing Session Contributions_Create']['requestBody']['content']['application/json'];
+export type UnlockOptions = operations['Editing Session File_Unlock']['requestBody']['content']['application/json'];
+export declare class EditingSessionFileClient {
+    #private;
+    constructor(uuid: string, client: CloudCannonClient);
+    get(): Promise<EditingSessionFile>;
+    getContributions(): Promise<EditingSessionFileContribution[]>;
+    createContribution(body: CreateContributionOptions): Promise<EditingSessionFileContribution>;
+    unlock(body: UnlockOptions): Promise<EditingSessionFileContribution>;
+}

package/dist/src/editing-session-file.js

@@ -0,0 +1,58 @@
+import { ApiError } from "./errors.js";
+export class EditingSessionFileClient {
+    #uuid;
+    #client;
+    constructor(uuid, client) {
+        this.#uuid = uuid;
+        this.#client = client;
+    }
+    async get() {
+        const resp = await this.#client.fetch(`/editing_session_files/${this.#uuid}`);
+        if (resp.status === 403) {
+            throw new Error('Error fetching editing session file. Permission denied');
+        }
+        const file = await resp.json();
+        return file;
+    }
+    async getContributions() {
+        const resp = await this.#client.fetch(`/editing_session_files/${this.#uuid}/contributions`);
+        if (resp.status === 403) {
+            throw new Error('Error fetching editing session file contributions. Permission denied');
+        }
+        const contributions = await resp.json();
+        return contributions;
+    }
+    async createContribution(body) {
+        const resp = await this.#client.fetch(`/editing_session_files/${this.#uuid}/contributions`, {
+            method: 'POST',
+            body,
+        });
+        if (resp.status === 401 || resp.status === 403) {
+            throw new Error('Error creating editing session file contribution. Permission denied');
+        }
+        if (resp.status === 422) {
+            const errorResp = await resp.json();
+            throw new ApiError('Error creating editing session file contribution. Invalid request', errorResp.errors, `/editing_session_files/${this.#uuid}/contributions`, { method: 'POST', body }, resp.status);
+        }
+        const contribution = await resp.json();
+        return contribution;
+    }
+    async unlock(body) {
+        const resp = await this.#client.fetch(`/editing_session_files/${this.#uuid}/unlock`, {
+            method: 'PUT',
+            body,
+        });
+        if (resp.status === 403) {
+            throw new Error('Error unlocking editing session file. Permission denied');
+        }
+        if (resp.status === 404) {
+            throw new Error('Error unlocking editing session file. File not found');
+        }
+        if (resp.status === 422) {
+            const errorResp = await resp.json();
+            throw new ApiError('Error unlocking editing session file. Invalid request', errorResp.errors, `/editing_session_files/${this.#uuid}/unlock`, { method: 'PUT', body }, resp.status);
+        }
+        const contribution = await resp.json();
+        return contribution;
+    }
+}

package/dist/src/editing-session.d.ts

@@ -0,0 +1,14 @@
+import type CloudCannonClient from '../index.ts';
+import type { EditingSession, EditingSessionFile } from '../index.ts';
+import type { operations } from '../schema.js';
+export type CreateEditingSessionFileOptions = operations['Editing Session Files_Create']['requestBody']['content']['application/json'];
+export type CommitEditingSessionOptions = operations['Editing Session_Commit']['requestBody']['content']['application/json'];
+export type CommitEditingSessionResponse = operations['Editing Session_Commit']['responses']['200']['content']['application/json'];
+export declare class EditingSessionClient {
+    #private;
+    constructor(uuid: string, client: CloudCannonClient);
+    get(): Promise<EditingSession>;
+    getFiles(): Promise<EditingSessionFile[]>;
+    createFile(body: CreateEditingSessionFileOptions): Promise<EditingSessionFile>;
+    commit(): Promise<CommitEditingSessionResponse>;
+}

package/dist/src/editing-session.js

@@ -0,0 +1,54 @@
+import { ApiError } from "./errors.js";
+export class EditingSessionClient {
+    #uuid;
+    #client;
+    constructor(uuid, client) {
+        this.#uuid = uuid;
+        this.#client = client;
+    }
+    async get() {
+        const resp = await this.#client.fetch(`/editing_sessions/${this.#uuid}`);
+        if (resp.status === 403) {
+            throw new Error('Error fetching editing session. Permission denied');
+        }
+        const editingSession = await resp.json();
+        return editingSession;
+    }
+    async getFiles() {
+        const resp = await this.#client.fetch(`/editing_sessions/${this.#uuid}/files`);
+        if (resp.status === 403) {
+            throw new Error('Error fetching editing session files. Permission denied');
+        }
+        const files = await resp.json();
+        return files;
+    }
+    async createFile(body) {
+        const resp = await this.#client.fetch(`/editing_sessions/${this.#uuid}/files`, {
+            method: 'POST',
+            body,
+        });
+        if (resp.status === 403) {
+            throw new Error('Error creating editing session file. Permission denied');
+        }
+        if (resp.status === 422) {
+            const errorResp = await resp.json();
+            throw new ApiError('Error creating editing session file. Invalid request', errorResp.errors, `/editing_sessions/${this.#uuid}/files`, { method: 'POST', body }, resp.status);
+        }
+        const file = await resp.json();
+        return file;
+    }
+    async commit() {
+        const resp = await this.#client.fetch(`/editing_sessions/${this.#uuid}/commit`, {
+            method: 'POST',
+        });
+        if (resp.status === 403) {
+            throw new Error('Error committing editing session. Permission denied');
+        }
+        if (resp.status === 422) {
+            const errorResp = await resp.json();
+            throw new ApiError('Error committing editing session. Invalid request', errorResp.errors, `/editing_sessions/${this.#uuid}/commit`, { method: 'POST' }, resp.status);
+        }
+        const result = await resp.json();
+        return result;
+    }
+}

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('item', 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,9 @@
 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 declare class InboxClient {
     #private;
     constructor(uuid: string, client: CloudCannonClient);
-    getSubmissions(): Promise<FormSubmission[]>;
+    getSubmissions(options?: PaginationOptions & SortingOptions<operations['Inbox Form Hooks_Index']> & FilterOptions<operations['Inbox Form Hooks_Index']>): 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,6 +1,7 @@
 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;
 }
@@ -10,13 +11,13 @@ export type CreateDamOptions = operations['DAMs_Create']['requestBody']['content
 export declare class OrgClient {
     #private;
     constructor(uuid: string, client: CloudCannonClient);
-    sites(): Promise<Site[]>;
+    sites(options?: PaginationOptions & SortingOptions<operations['Sites_Index']> & FilterOptions<operations['Sites_Index']>): 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?: PaginationOptions & SortingOptions<operations['Organization Inboxes_Index']> & FilterOptions<operations['Organization Inboxes_Index']>): Promise<PaginatedResponse<Inbox>>;
     createInbox(body: CreateInboxOptions): Promise<Inbox>;
-    getDams(): Promise<Dam[]>;
+    getDams(options?: PaginationOptions & SortingOptions<operations['DAMs_Index']> & FilterOptions<operations['DAMs_Index']>): 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, 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,8 +23,14 @@ 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 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];
+export type UploadFileOptions = {
+    type?: string;
+    overwriteExistingFile?: boolean;
+};
 export declare class SiteClient {
     #private;
     constructor(uuid: string, client: CloudCannonClient);
@@ -32,10 +39,15 @@ export declare class SiteClient {
     delete(): Promise<void>;
     copy(body: CopySiteOptions): Promise<Site>;
     updateBuildConfig(options: BuildConfiguration): Promise<Site>;
-    getBuilds(): Promise<Build[]>;
+    getBuilds(options?: PaginationOptions & SortingOptions<operations['Builds_Index']> & FilterOptions<operations['Builds_Index']>): Promise<PaginatedResponse<Build>>;
     rebuild(): Promise<void>;
+    listBackups(options?: PaginationOptions & SortingOptions<operations['Backups_Index']> & FilterOptions<operations['Backups_Index']>): Promise<PaginatedResponse<Backup>>;
+    createBackup(body?: CreateBackupOptions): Promise<{
+        socket_message_id?: string;
+    }>;
+    listFiles(): Promise<FileListing[]>;
     getFile(path: string): Promise<Response>;
-    getSyncs(): Promise<Sync[]>;
+    getSyncs(options?: PaginationOptions & SortingOptions<operations['Syncs_Index']> & FilterOptions<operations['Syncs_Index']>): Promise<PaginatedResponse<Sync>>;
     getScan(): Promise<SiteScan>;
     getScreenshotHashes(): Promise<Record<string, string>>;
     getScreenshot(device: 'desktop' | 'mobile', path: string): Promise<Response>;
@@ -48,4 +60,8 @@ export declare class SiteClient {
     connectInbox(body: ConnectInboxOptions): Promise<SiteInbox>;
     getDamConnections(): Promise<SiteDam[]>;
     connectDam(body: ConnectDamOptions): Promise<SiteDam>;
+    getEditingSessions(): Promise<EditingSession[]>;
+    createEditingSession(): Promise<EditingSession>;
+    getLatestEditingSession(): Promise<EditingSession>;
+    uploadFile(path: string, content: BlobPart, options?: UploadFileOptions): 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,42 @@ 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) {
+            throw new Error('Error fetching files. Permission denied');
+        }
+        if (resp.status === 422) {
+            const errorResp = await resp.json();
+            throw new ApiError('Error fetching files. Invalid request', errorResp.errors, `/sites/${this.#uuid}/files`, {}, resp.status);
+        }
+        const files = await resp.json();
+        return files;
+    }
     async getFile(path) {
         const resp = await this.#client.fetch(`/sites/${this.#uuid}/files/${encodeURIComponent(path)}`);
         if (resp.status === 401 || resp.status === 403) {
@@ -100,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`);
@@ -251,4 +290,83 @@ export class SiteClient {
         const dam = await resp.json();
         return dam;
     }
+    async getEditingSessions() {
+        const resp = await this.#client.fetch(`/sites/${this.#uuid}/editing_sessions`);
+        if (resp.status === 403) {
+            throw new Error('Error fetching editing sessions. Permission denied');
+        }
+        const editingSessions = await resp.json();
+        return editingSessions;
+    }
+    async createEditingSession() {
+        const resp = await this.#client.fetch(`/sites/${this.#uuid}/editing_sessions`, {
+            method: 'POST',
+        });
+        if (resp.status === 401 || resp.status === 403) {
+            throw new Error('Error creating editing session. Permission denied');
+        }
+        if (resp.status === 422) {
+            const errorResp = await resp.json();
+            throw new ApiError('Error creating editing session. Invalid request', errorResp.errors, `/sites/${this.#uuid}/editing_sessions`, { method: 'POST' }, resp.status);
+        }
+        const editingSession = await resp.json();
+        return editingSession;
+    }
+    async getLatestEditingSession() {
+        const resp = await this.#client.fetch(`/sites/${this.#uuid}/editing_sessions/latest`);
+        if (resp.status === 403) {
+            throw new Error('Error fetching latest editing session. Permission denied');
+        }
+        const editingSession = await resp.json();
+        return editingSession;
+    }
+    async uploadFile(path, content, options = {}) {
+        if (!path.startsWith('/')) {
+            path = `/${path}`;
+        }
+        const files = await this.listFiles();
+        const existingFile = files.find((file) => file.sitePath === path);
+        if (existingFile && !options.overwriteExistingFile) {
+            throw new Error('File already exists and overwriteExistingFile is not set');
+        }
+        const uploadData = await this.#client.getUploadData();
+        const editingSession = await this.createEditingSession();
+        const file = await this.#client.editingSession(editingSession.uuid).createFile({
+            path,
+            source_path: existingFile ? path : undefined,
+            edit_type: 'update',
+        });
+        const contributions = await this.#client.editingSessionFile(file.uuid).getContributions();
+        contributions.sort((a, b) => a.updated_at.localeCompare(b.updated_at));
+        const latestContribution = contributions.at(-1);
+        if (latestContribution && !options.overwriteExistingFile) {
+            throw new Error('File already exists and overwriteExistingFile is not set');
+        }
+        const s3Key = `${uploadData.prefix}/${Date.now()}${path}`;
+        const formData = new FormData();
+        formData.append('key', s3Key);
+        Object.keys(uploadData.fields).forEach((field) => {
+            if (field !== 'key') {
+                formData.append(field, uploadData.fields[field]);
+            }
+        });
+        formData.append('file', new Blob([content], { type: options.type ?? 'text/plain' }));
+        const uploadResp = await fetch(uploadData.url, {
+            method: 'POST',
+            body: formData,
+        });
+        const etag = uploadResp.headers.get('ETag');
+        if (!etag) {
+            throw new Error('ETag not found in upload response');
+        }
+        const contentHash = etag.slice(1, -1);
+        await this.#client.editingSessionFile(file.uuid).createContribution({
+            s3_key: s3Key,
+            content_hash: contentHash,
+            previous_content_hash: latestContribution?.content_hash ?? existingFile?.md5,
+        });
+        await this.#client.editingSessionFile(file.uuid).unlock({
+            previous_content_hash: contentHash,
+        });
+    }
 }

package/dist/src/sync.d.ts

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

package/dist/src/sync.js

@@ -0,0 +1,15 @@
+export class SyncClient {
+    #uuid;
+    #client;
+    constructor(uuid, client) {
+        this.#uuid = uuid;
+        this.#client = client;
+    }
+    async get() {
+        const resp = await this.#client.fetch(`/syncs/${this.#uuid}`);
+        if (resp.status === 401 || resp.status === 403) {
+            throw new Error('Error fetching sync. Permission denied');
+        }
+        return resp;
+    }
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@cloudcannon/sdk",
   "type": "module",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "description": "REST API client for the CloudCannon CMS.",
   "keywords": [
     "cloudcannon",
@@ -43,7 +43,8 @@
     "test:watch": "node --test --watch",
     "test:coverage": "node --test --test-coverage --test-reporter=lcov --test-reporter-destination=lcov.info",
     "lint": "biome check && tsc --noEmit",
-    "lint:fix": "biome check --fix"
+    "lint:fix": "biome check --fix",
+    "generate-schema": "npx openapi-typescript $1 -o ./schema.ts"
   },
   "author": "CloudCannon <support@cloudcannon.com>",
   "license": "ISC",