@opencloud-eu/web-client 0.1.0

package/dist/src/webdav/constants/dav.d.ts

@@ -0,0 +1,106 @@
+import { Audio, GeoCoordinates, Image, Photo } from '../../graph/generated';
+export declare abstract class DavPermission {
+    static readonly Shared: string;
+    static readonly Shareable: string;
+    static readonly Mounted: string;
+    static readonly Deletable: string;
+    static readonly Renameable: string;
+    static readonly Moveable: string;
+    static readonly Updateable: string;
+    static readonly FileUpdateable: string;
+    static readonly FolderCreateable: string;
+    static readonly Deny: string;
+    static readonly SecureView: string;
+}
+export type DavErrorCode = 'ERR_LISTING_MEMBERS_NOT_ALLOWED' | 'ERR_INVALID_CREDENTIALS' | 'ERR_MISSING_BASIC_AUTH' | 'ERR_MISSING_BEARER_AUTH' | 'ERR_FILE_NOT_FOUND_IN_ROOT';
+export declare enum DavMethod {
+    copy = "COPY",
+    delete = "DELETE",
+    lock = "LOCK",
+    mkcol = "MKCOL",
+    move = "MOVE",
+    propfind = "PROPFIND",
+    proppatch = "PROPPATCH",
+    put = "PUT",
+    report = "REPORT",
+    unlock = "UNLOCK"
+}
+type M<V, T> = {
+    value: V;
+    type: T;
+};
+declare const DavPropertyMapping: {
+    readonly Permissions: M<"permissions", string>;
+    readonly IsFavorite: M<"favorite", number>;
+    readonly FileId: M<"fileid", string>;
+    readonly FileParent: M<"file-parent", string>;
+    readonly Name: M<"name", string>;
+    readonly OwnerId: M<"owner-id", string>;
+    readonly OwnerDisplayName: M<"owner-display-name", string>;
+    readonly PrivateLink: M<"privatelink", string>;
+    readonly ContentLength: M<"getcontentlength", number>;
+    readonly ContentSize: M<"size", number>;
+    readonly LastModifiedDate: M<"getlastmodified", string>;
+    readonly Tags: M<"tags", string | number>;
+    readonly Audio: {
+        readonly value: "audio";
+        readonly type: Audio;
+    };
+    readonly Location: {
+        readonly value: "location";
+        readonly type: GeoCoordinates;
+    };
+    readonly Image: {
+        readonly value: "image";
+        readonly type: Image;
+    };
+    readonly Photo: {
+        readonly value: "photo";
+        readonly type: Photo;
+    };
+    readonly ETag: M<"getetag", string>;
+    readonly MimeType: M<"getcontenttype", string>;
+    readonly ResourceType: M<"resourcetype", string[]>;
+    readonly LockDiscovery: {
+        readonly value: "lockdiscovery";
+        readonly type: Record<string, unknown>;
+    };
+    readonly LockOwner: M<"owner", string>;
+    readonly LockTime: M<"locktime", string>;
+    readonly ActiveLock: {
+        readonly value: "activelock";
+        readonly type: Record<string, unknown>;
+    };
+    readonly DownloadURL: M<"downloadURL", string>;
+    readonly Highlights: M<"highlights", string>;
+    readonly MetaPathForUser: M<"meta-path-for-user", string>;
+    readonly RemoteItemId: M<"remote-item-id", string>;
+    readonly ShareId: M<"shareid", string>;
+    readonly ShareRoot: M<"shareroot", string>;
+    readonly ShareTypes: {
+        readonly value: "share-types";
+        readonly type: Record<string, number[]>;
+    };
+    readonly SharePermissions: M<"share-permissions", string>;
+    readonly TrashbinOriginalFilename: M<"trashbin-original-filename", string>;
+    readonly TrashbinOriginalLocation: M<"trashbin-original-location", string>;
+    readonly TrashbinDeletedDate: M<"trashbin-delete-datetime", string>;
+    readonly PublicLinkItemType: M<"public-link-item-type", string>;
+    readonly PublicLinkPermission: M<"public-link-permission", string>;
+    readonly PublicLinkExpiration: M<"public-link-expiration", string>;
+    readonly PublicLinkShareDate: M<"public-link-share-datetime", string>;
+    readonly PublicLinkShareOwner: M<"public-link-share-owner", string>;
+};
+type DavPropertyMappingType = typeof DavPropertyMapping;
+export declare const DavProperty: { [K in keyof DavPropertyMappingType as K]: DavPropertyMappingType[K]["value"]; };
+export type DavFileInfoResponse = {
+    [K in keyof DavPropertyMappingType as DavPropertyMappingType[K]['value']]: DavPropertyMappingType[K]['type'];
+};
+export type DavPropertyValue = (typeof DavProperty)[keyof typeof DavProperty];
+export declare abstract class DavProperties {
+    static readonly Default: DavPropertyValue[];
+    static readonly PublicLink: DavPropertyValue[];
+    static readonly Trashbin: DavPropertyValue[];
+    static readonly DavNamespace: DavPropertyValue[];
+}
+export {};

package/dist/src/webdav/constants/index.d.ts

@@ -0,0 +1 @@
+export * from './dav';

package/dist/src/webdav/copyFiles.d.ts

@@ -0,0 +1,15 @@
+import { SpaceResource } from '../helpers';
+import { DAV, DAVRequestOptions } from './client';
+import { WebDavOptions } from './types';
+export declare const CopyFilesFactory: (dav: DAV, options: WebDavOptions) => {
+    copyFiles(sourceSpace: SpaceResource, { path: sourcePath, fileId: sourceFileId }: {
+        path?: string;
+        fileId?: string;
+    }, targetSpace: SpaceResource, { path: targetPath, parentFolderId, name }: {
+        path?: string;
+        parentFolderId?: string;
+        name?: string;
+    }, { overwrite, ...opts }?: {
+        overwrite?: boolean;
+    } & DAVRequestOptions): Promise<import('./client').DavResult>;
+};

package/dist/src/webdav/createFolder.d.ts

@@ -0,0 +1,14 @@
+import { FolderResource, SpaceResource } from '../helpers';
+import { GetFileInfoFactory } from './getFileInfo';
+import { DAV, DAVRequestOptions } from './client/dav';
+import { WebDavOptions } from './types';
+type CreateFolderOptions = {
+    path: string;
+    parentFolderId?: string;
+    folderName?: string;
+    fetchFolder?: boolean;
+} & DAVRequestOptions;
+export declare const CreateFolderFactory: (dav: DAV, getFileInfoFactory: ReturnType<typeof GetFileInfoFactory>, options: WebDavOptions) => {
+    createFolder(space: SpaceResource, { path, parentFolderId, folderName, fetchFolder, ...opts }: CreateFolderOptions): Promise<FolderResource>;
+};
+export {};

package/dist/src/webdav/deleteFile.d.ts

@@ -0,0 +1,8 @@
+import { SpaceResource } from '../helpers';
+import { WebDavOptions } from './types';
+import { DAV, DAVRequestOptions } from './client';
+export declare const DeleteFileFactory: (dav: DAV, options: WebDavOptions) => {
+    deleteFile(space: SpaceResource, { path, ...opts }: {
+        path: string;
+    } & DAVRequestOptions): Promise<import('./client').DavResult>;
+};

package/dist/src/webdav/getFileContents.d.ts

@@ -0,0 +1,17 @@
+import { SpaceResource } from '../helpers';
+import { WebDavOptions } from './types';
+import { DAV, DAVRequestOptions } from './client';
+import { ResponseType } from 'axios';
+export type GetFileContentsResponse = {
+    body: any;
+    [key: string]: any;
+};
+export declare const GetFileContentsFactory: (dav: DAV, { axiosClient }: WebDavOptions) => {
+    getFileContents(space: SpaceResource, { fileId, path }: {
+        fileId?: string;
+        path?: string;
+    }, { responseType, noCache, headers, ...opts }?: {
+        responseType?: ResponseType;
+        noCache?: boolean;
+    } & DAVRequestOptions): Promise<GetFileContentsResponse>;
+};

package/dist/src/webdav/getFileInfo.d.ts

@@ -0,0 +1,9 @@
+import { Resource, SpaceResource } from '../helpers';
+import { ListFilesFactory, ListFilesOptions } from './listFiles';
+import { WebDavOptions } from './types';
+export declare const GetFileInfoFactory: (listFilesFactory: ReturnType<typeof ListFilesFactory>, options?: WebDavOptions) => {
+    getFileInfo(space: SpaceResource, resource?: {
+        path?: string;
+        fileId?: string;
+    }, options?: ListFilesOptions): Promise<Resource>;
+};

package/dist/src/webdav/getFileUrl.d.ts

@@ -0,0 +1,15 @@
+import { Resource, SpaceResource } from '../helpers';
+import { GetFileContentsFactory } from './getFileContents';
+import { WebDavOptions } from './types';
+import { DAV, DAVRequestOptions } from './client';
+export declare const GetFileUrlFactory: (dav: DAV, getFileContentsFactory: ReturnType<typeof GetFileContentsFactory>, { axiosClient, baseUrl }: WebDavOptions) => {
+    getFileUrl(space: SpaceResource, resource: Resource, { disposition, isUrlSigningEnabled, signUrlTimeout, version, doHeadRequest, username, ...opts }: {
+        disposition?: "inline" | "attachment";
+        isUrlSigningEnabled?: boolean;
+        signUrlTimeout?: number;
+        version?: string;
+        doHeadRequest?: boolean;
+        username?: string;
+    } & DAVRequestOptions): Promise<string>;
+    revokeUrl: (url: string) => void;
+};

package/dist/src/webdav/getPathForFileId.d.ts

@@ -0,0 +1,5 @@
+import { DAV, DAVRequestOptions } from './client';
+import { WebDavOptions } from './types';
+export declare const GetPathForFileIdFactory: (dav: DAV, options: WebDavOptions) => {
+    getPathForFileId(id: string, opts?: DAVRequestOptions): Promise<string>;
+};

package/dist/src/webdav/getPublicFileUrl.d.ts

@@ -0,0 +1,6 @@
+import { SpaceResource } from '../helpers';
+import { DAV } from './client';
+import { WebDavOptions } from './types';
+export declare const GetPublicFileUrlFactory: (dav: DAV, options: WebDavOptions) => {
+    getPublicFileUrl(space: SpaceResource, publicLinkToken: string): string;
+};

package/dist/src/webdav/index.d.ts

@@ -0,0 +1,7 @@
+import { Headers } from 'webdav';
+import { WebDAV } from './types';
+export * from './constants';
+export * from './types';
+export type { ListFilesOptions, ListFilesResult } from './listFiles';
+export type { GetFileContentsResponse } from './getFileContents';
+export declare const webdav: (baseURI: string, headers?: () => Headers) => WebDAV;

package/dist/src/webdav/listFavoriteFiles.d.ts

@@ -0,0 +1,12 @@
+import { WebDavOptions } from './types';
+import { DAV, DAVRequestOptions } from './client';
+import { DavPropertyValue } from './constants';
+export declare const ListFavoriteFilesFactory: (dav: DAV, options: WebDavOptions) => {
+    listFavoriteFiles({ davProperties, username, ...opts }?: {
+        davProperties?: DavPropertyValue[];
+        username?: string;
+    } & DAVRequestOptions): Promise<{
+        results: import('..').WebDavResponseResource[];
+        range: string;
+    }>;
+};

package/dist/src/webdav/listFileVersions.d.ts

@@ -0,0 +1,5 @@
+import { WebDavOptions } from './types';
+import { DAV, DAVRequestOptions } from './client';
+export declare const ListFileVersionsFactory: (dav: DAV, options: WebDavOptions) => {
+    listFileVersions(id: string, opts?: DAVRequestOptions): Promise<import('..').Resource[]>;
+};

package/dist/src/webdav/listFiles.d.ts

@@ -0,0 +1,21 @@
+import { Resource } from '../helpers/resource';
+import { DavPropertyValue } from './constants';
+import { SpaceResource } from '../helpers';
+import { DAV, DAVRequestOptions } from './client';
+import { GetPathForFileIdFactory } from './getPathForFileId';
+import { WebDavOptions } from './types';
+export type ListFilesOptions = {
+    depth?: number;
+    davProperties?: DavPropertyValue[];
+    isTrash?: boolean;
+} & DAVRequestOptions;
+export declare const ListFilesFactory: (dav: DAV, pathForFileIdFactory: ReturnType<typeof GetPathForFileIdFactory>, options: WebDavOptions) => {
+    listFiles(space: SpaceResource, { path, fileId }?: {
+        path?: string;
+        fileId?: string;
+    }, { depth, davProperties, isTrash, ...opts }?: ListFilesOptions): Promise<ListFilesResult>;
+};
+export interface ListFilesResult {
+    resource: Resource;
+    children?: Resource[];
+}

package/dist/src/webdav/moveFiles.d.ts

@@ -0,0 +1,15 @@
+import { SpaceResource } from '../helpers';
+import { WebDavOptions } from './types';
+import { DAV, DAVRequestOptions } from './client';
+export declare const MoveFilesFactory: (dav: DAV, options: WebDavOptions) => {
+    moveFiles(sourceSpace: SpaceResource, { path: sourcePath, fileId: sourceFileId }: {
+        path?: string;
+        fileId?: string;
+    }, targetSpace: SpaceResource, { path: targetPath, parentFolderId, name }: {
+        path?: string;
+        parentFolderId?: string;
+        name?: string;
+    }, { overwrite, ...opts }?: {
+        overwrite?: boolean;
+    } & DAVRequestOptions): Promise<import('./client').DavResult>;
+};

package/dist/src/webdav/putFileContents.d.ts

@@ -0,0 +1,18 @@
+import { SpaceResource } from '../helpers';
+import { GetFileInfoFactory } from './getFileInfo';
+import { WebDavOptions } from './types';
+import { DAV, DAVRequestOptions } from './client';
+import { ProgressEventCallback } from 'webdav';
+type PutFileContentsOptions = {
+    fileName?: string;
+    parentFolderId?: string;
+    path?: string;
+    content?: string | ArrayBuffer;
+    previousEntityTag?: string;
+    overwrite?: boolean;
+    onUploadProgress?: ProgressEventCallback;
+} & DAVRequestOptions;
+export declare const PutFileContentsFactory: (dav: DAV, getFileInfoFactory: ReturnType<typeof GetFileInfoFactory>, options: WebDavOptions) => {
+    putFileContents(space: SpaceResource, { fileName, path, parentFolderId, content, previousEntityTag, overwrite, onUploadProgress, ...opts }: PutFileContentsOptions): Promise<import('..').Resource>;
+};
+export {};

package/dist/src/webdav/restoreFile.d.ts

@@ -0,0 +1,12 @@
+import { SpaceResource } from '../helpers';
+import { WebDavOptions } from './types';
+import { DAV, DAVRequestOptions } from './client';
+export declare const RestoreFileFactory: (dav: DAV, options: WebDavOptions) => {
+    restoreFile(space: SpaceResource, { id }: {
+        id: string;
+    }, { path: restorePath }: {
+        path: string;
+    }, { overwrite, ...opts }?: {
+        overwrite?: boolean;
+    } & DAVRequestOptions): Promise<import('./client').DavResult>;
+};

package/dist/src/webdav/restoreFileVersion.d.ts

@@ -0,0 +1,10 @@
+import { SpaceResource } from '../helpers';
+import { WebDavOptions } from './types';
+import { DAV, DAVRequestOptions } from './client';
+export declare const RestoreFileVersionFactory: (dav: DAV, options: WebDavOptions) => {
+    restoreFileVersion(space: SpaceResource, { parentFolderId, name, path }: {
+        parentFolderId?: string;
+        name?: string;
+        path?: string;
+    }, versionId: string, opts?: DAVRequestOptions): Promise<import('./client').DavResult>;
+};

package/dist/src/webdav/search.d.ts

@@ -0,0 +1,15 @@
+import { SearchResource } from '../helpers';
+import { WebDavOptions } from './types';
+import { DavPropertyValue } from './constants';
+import { DAV, DAVRequestOptions } from './client';
+export type SearchOptions = {
+    davProperties?: DavPropertyValue[];
+    searchLimit?: number;
+} & DAVRequestOptions;
+export type SearchResult = {
+    resources: SearchResource[];
+    totalResults: number;
+};
+export declare const SearchFactory: (dav: DAV, options: WebDavOptions) => {
+    search(term: string, { davProperties, searchLimit, ...opts }: SearchOptions): Promise<SearchResult>;
+};

package/dist/src/webdav/setFavorite.d.ts

@@ -0,0 +1,8 @@
+import { SpaceResource } from '../helpers';
+import { WebDavOptions } from './types';
+import { DAV, DAVRequestOptions } from './client';
+export declare const SetFavoriteFactory: (dav: DAV, options: WebDavOptions) => {
+    setFavorite(space: SpaceResource, { path }: {
+        path: string;
+    }, value: unknown, opts?: DAVRequestOptions): Promise<import('./client').DavResult>;
+};

package/dist/src/webdav/types.d.ts

@@ -0,0 +1,47 @@
+import { CreateFolderFactory } from './createFolder';
+import { GetFileContentsFactory } from './getFileContents';
+import { GetFileInfoFactory } from './getFileInfo';
+import { GetFileUrlFactory } from './getFileUrl';
+import { GetPublicFileUrlFactory } from './getPublicFileUrl';
+import { ListFilesFactory } from './listFiles';
+import { PutFileContentsFactory } from './putFileContents';
+import { CopyFilesFactory } from './copyFiles';
+import { MoveFilesFactory } from './moveFiles';
+import { DeleteFileFactory } from './deleteFile';
+import { RestoreFileFactory } from './restoreFile';
+import { ListFileVersionsFactory } from './listFileVersions';
+import { RestoreFileVersionFactory } from './restoreFileVersion';
+import { ClearTrashBinFactory } from './clearTrashBin';
+import { SearchFactory } from './search';
+import { GetPathForFileIdFactory } from './getPathForFileId';
+import { SetFavoriteFactory } from './setFavorite';
+import { ListFavoriteFilesFactory } from './listFavoriteFiles';
+import { AxiosInstance } from 'axios';
+import { Headers } from 'webdav';
+export interface WebDavOptions {
+    axiosClient: AxiosInstance;
+    baseUrl: string;
+    headers?: () => Headers;
+}
+export interface WebDAV {
+    getFileInfo: ReturnType<typeof GetFileInfoFactory>['getFileInfo'];
+    getFileUrl: ReturnType<typeof GetFileUrlFactory>['getFileUrl'];
+    getPublicFileUrl: ReturnType<typeof GetPublicFileUrlFactory>['getPublicFileUrl'];
+    revokeUrl: ReturnType<typeof GetFileUrlFactory>['revokeUrl'];
+    listFiles: ReturnType<typeof ListFilesFactory>['listFiles'];
+    createFolder: ReturnType<typeof CreateFolderFactory>['createFolder'];
+    getFileContents: ReturnType<typeof GetFileContentsFactory>['getFileContents'];
+    putFileContents: ReturnType<typeof PutFileContentsFactory>['putFileContents'];
+    getPathForFileId: ReturnType<typeof GetPathForFileIdFactory>['getPathForFileId'];
+    copyFiles: ReturnType<typeof CopyFilesFactory>['copyFiles'];
+    moveFiles: ReturnType<typeof MoveFilesFactory>['moveFiles'];
+    deleteFile: ReturnType<typeof DeleteFileFactory>['deleteFile'];
+    restoreFile: ReturnType<typeof RestoreFileFactory>['restoreFile'];
+    listFileVersions: ReturnType<typeof ListFileVersionsFactory>['listFileVersions'];
+    restoreFileVersion: ReturnType<typeof RestoreFileVersionFactory>['restoreFileVersion'];
+    clearTrashBin: ReturnType<typeof ClearTrashBinFactory>['clearTrashBin'];
+    search: ReturnType<typeof SearchFactory>['search'];
+    listFavoriteFiles: ReturnType<typeof ListFavoriteFilesFactory>['listFavoriteFiles'];
+    setFavorite: ReturnType<typeof SetFavoriteFactory>['setFavorite'];
+    registerExtraProp(name: string): any;
+}

package/dist/src/webdav/utils.d.ts

@@ -0,0 +1,13 @@
+import { SpaceResource } from '../helpers';
+/**
+ * Builds a webdav path based on a given `path` or `fileId`. A `path` takes precedence.
+ *
+ * Public spaces currently don't support id-based paths, hence `path` needs to be provided.
+ * Some id-based requests need a resource `name` appended (mkcol, put, copy, move, restore).
+ * In this case, the `fileId` is supposed to be the id of the parent folder.
+ **/
+export declare const getWebDavPath: (space: SpaceResource, { fileId, path, name }: {
+    fileId?: string;
+    path?: string;
+    name?: string;
+}) => string;