Generate DBFS, Jobs, and Libraries APIs (#25)

* Import generated code

* Fix undefined access

* Pin Jobs API calls to 2.1

Author: pietern

packages/databricks-sdk-js/src/apis/dbfs.ts

@@ -2,39 +2,191 @@
 
 import {ApiClient} from "../api-client";
 
-export interface DbfsPutRequest {
+import * as delegate from "./delegate";
+
+//
+// Enums.
+//
+
+//
+// Subtypes used in request/response types.
+//
+
+export interface FileInfo {
+    path?: string;
+    is_dir?: boolean;
+    file_size?: number;
+    modification_time?: number;
+}
+
+//
+// Request/response types.
+//
+
+export interface ReadRequest {
+    path: string;
+    offset?: number;
+    length?: number;
+}
+
+export interface ReadResponse {
+    bytes_read?: number;
+    data?: string;
+}
+
+export interface GetStatusRequest {
     path: string;
-    contents: string;
-    overwrite: boolean;
 }
 
-export interface DbfsPutResponse {}
+export interface GetStatusResponse {
+    path?: string;
+    is_dir?: boolean;
+    file_size?: number;
+    modification_time?: number;
+}
 
-export interface DbfsDeleteRequest {
+export interface ListStatusRequest {
     path: string;
 }
 
-export interface DbfsDeleteResponse {
-    error_code?: string;
-    message?: string;
+export interface ListStatusResponse {
+    files?: Array<FileInfo>;
 }
 
+export interface PutRequest {
+    path: string;
+    contents?: string;
+    overwrite?: boolean;
+}
+
+export interface PutResponse {}
+
+export interface MkDirsRequest {
+    path: string;
+}
+
+export interface MkDirsResponse {}
+
+export interface MoveRequest {
+    source_path: string;
+    destination_path: string;
+}
+
+export interface MoveResponse {}
+
+export interface DeleteRequest {
+    path: string;
+    recursive?: boolean;
+}
+
+export interface DeleteResponse {}
+
+export interface CreateRequest {
+    path: string;
+    overwrite?: boolean;
+}
+
+export interface CreateResponse {
+    handle?: number;
+}
+
+export interface AddBlockRequest {
+    handle: number;
+    data: string;
+}
+
+export interface AddBlockResponse {}
+
+export interface CloseRequest {
+    handle: number;
+}
+
+export interface CloseResponse {}
+
 export class DbfsService {
-    constructor(readonly client: ApiClient) {}
+    readonly client: ApiClient;
+
+    constructor(client: ApiClient) {
+        this.client = client;
+    }
 
-    async put(req: DbfsPutRequest): Promise<DbfsPutResponse> {
+    async read(request: ReadRequest): Promise<ReadResponse> {
+        return (await this.client.request(
+            "/api/2.0/dbfs/read",
+            "GET",
+            request
+        )) as ReadResponse;
+    }
+
+    async getStatus(request: GetStatusRequest): Promise<GetStatusResponse> {
+        return (await this.client.request(
+            "/api/2.0/dbfs/get-status",
+            "GET",
+            request
+        )) as GetStatusResponse;
+    }
+
+    async list(request: ListStatusRequest): Promise<ListStatusResponse> {
+        return (await this.client.request(
+            "/api/2.0/dbfs/list",
+            "GET",
+            request
+        )) as ListStatusResponse;
+    }
+
+    async put(request: PutRequest): Promise<PutResponse> {
         return (await this.client.request(
             "/api/2.0/dbfs/put",
             "POST",
-            req
-        )) as DbfsPutResponse;
+            request
+        )) as PutResponse;
+    }
+
+    async mkdirs(request: MkDirsRequest): Promise<MkDirsResponse> {
+        return (await this.client.request(
+            "/api/2.0/dbfs/mkdirs",
+            "POST",
+            request
+        )) as MkDirsResponse;
+    }
+
+    async move(request: MoveRequest): Promise<MoveResponse> {
+        return (await this.client.request(
+            "/api/2.0/dbfs/move",
+            "POST",
+            request
+        )) as MoveResponse;
     }
 
-    async delete(req: DbfsDeleteRequest): Promise<DbfsDeleteResponse> {
+    async delete(request: DeleteRequest): Promise<DeleteResponse> {
         return (await this.client.request(
             "/api/2.0/dbfs/delete",
             "POST",
-            req
-        )) as DbfsDeleteResponse;
+            request
+        )) as DeleteResponse;
+    }
+
+    async create(request: CreateRequest): Promise<CreateResponse> {
+        return (await this.client.request(
+            "/api/2.0/dbfs/create",
+            "POST",
+            request
+        )) as CreateResponse;
+    }
+
+    async addBlock(request: AddBlockRequest): Promise<AddBlockResponse> {
+        return (await this.client.request(
+            "/api/2.0/dbfs/add-block",
+            "POST",
+            request
+        )) as AddBlockResponse;
+    }
+
+    async close(request: CloseRequest): Promise<CloseResponse> {
+        return (await this.client.request(
+            "/api/2.0/dbfs/close",
+            "POST",
+            request
+        )) as CloseResponse;
     }
 }

packages/databricks-sdk-js/src/apis/jobs.integ.ts

@@ -28,7 +28,7 @@ describe(__filename, function () {
             overwrite: true,
         });
 
-        let res = await jobsService.submit({
+        let res = await jobsService.submitRun({
             tasks: [
                 {
                     task_key: "hello_world",
@@ -41,26 +41,26 @@ describe(__filename, function () {
         });
 
         // console.log(res);
-        let runId = res.run_id;
+        let runId = res.run_id!;
 
         while (true) {
             await sleep(3000);
             let run = await jobsService.getRun({run_id: runId});
-            let state = run.state.life_cycle_state;
+            let state = run.state!.life_cycle_state!;
 
             // console.log(`State: ${state} - URL: ${run.run_page_url}`);
 
             if (state === "INTERNAL_ERROR" || state === "TERMINATED") {
                 let output = await jobsService.getRunOutput({
-                    run_id: run.tasks[0].run_id,
+                    run_id: run.tasks![0].run_id!,
                 });
                 // console.log(output);
 
-                assert.equal(output.logs.trim(), "hello from job");
+                assert.equal(output.logs!.trim(), "hello from job");
                 break;
             }
         }
 
-        dbfsApi.delete({path: jobPath});
+        await dbfsApi.delete({path: jobPath});
     });
 });