@ogcio/building-blocks-sdk 0.0.1

package/src/client/clients/scheduler/index.ts

@@ -0,0 +1,28 @@
+import type createClient from "openapi-fetch";
+import { SCHEDULER } from "../../../types/index.js";
+import BaseClient from "../../base-client.js";
+import type { paths } from "./schema.js";
+
+class Scheduler extends BaseClient<paths> {
+  declare client: ReturnType<typeof createClient<paths>>;
+  protected serviceName = SCHEDULER;
+
+  async scheduleTasks(
+    tasks: {
+      webhookUrl: string;
+      webhookAuth: string;
+      executeAt: string;
+    }[],
+  ) {
+    return this.client
+      .POST("/api/v1/tasks/", {
+        body: tasks,
+      })
+      .then(
+        (response) => this.formatResponse(response),
+        (reason) => this.formatError(reason),
+      );
+  }
+}
+
+export default Scheduler;

package/src/client/clients/scheduler/open-api-definition.json

@@ -0,0 +1,120 @@
+{
+  "openapi": "3.0.3",
+  "info": {
+    "title": "OGCIO Scheduler API",
+    "description": "API for OGCIO Scheduler",
+    "version": "0.1.0"
+  },
+  "components": {
+    "schemas": {}
+  },
+  "paths": {
+    "/health": {
+      "get": {
+        "responses": {
+          "200": {
+            "description": "Default Response"
+          }
+        }
+      }
+    },
+    "/api/v1/tasks/": {
+      "post": {
+        "tags": [
+          "Tasks"
+        ],
+        "requestBody": {
+          "content": {
+            "application/json": {
+              "schema": {
+                "type": "array",
+                "items": {
+                  "type": "object",
+                  "properties": {
+                    "webhookUrl": {
+                      "format": "uri",
+                      "type": "string"
+                    },
+                    "webhookAuth": {
+                      "type": "string"
+                    },
+                    "executeAt": {
+                      "format": "date-time",
+                      "type": "string"
+                    }
+                  },
+                  "required": [
+                    "webhookUrl",
+                    "webhookAuth",
+                    "executeAt"
+                  ]
+                }
+              }
+            }
+          }
+        },
+        "responses": {
+          "202": {
+            "description": "Default Response"
+          },
+          "500": {
+            "description": "Default Response",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "object",
+                  "properties": {
+                    "code": {
+                      "description": "Code used to categorize the error",
+                      "type": "string"
+                    },
+                    "detail": {
+                      "description": "Description of the error",
+                      "type": "string"
+                    },
+                    "requestId": {
+                      "description": "Unique request id. This one will be used to troubleshoot the problems",
+                      "type": "string"
+                    },
+                    "name": {
+                      "description": "Name of the error type",
+                      "type": "string"
+                    },
+                    "validation": {
+                      "description": "List of the validation errors",
+                      "type": "array",
+                      "items": {
+                        "type": "object",
+                        "properties": {
+                          "fieldName": {
+                            "type": "string"
+                          },
+                          "message": {
+                            "type": "string"
+                          }
+                        },
+                        "required": [
+                          "fieldName",
+                          "message"
+                        ]
+                      }
+                    },
+                    "validationContext": {
+                      "type": "string"
+                    }
+                  },
+                  "required": [
+                    "code",
+                    "detail",
+                    "requestId",
+                    "name"
+                  ]
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}

package/src/client/clients/scheduler/schema.ts

@@ -0,0 +1,113 @@
+export interface paths {
+    "/health": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description Default Response */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/tasks/": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        post: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: {
+                content: {
+                    "application/json": {
+                        /** Format: uri */
+                        webhookUrl: string;
+                        webhookAuth: string;
+                        /** Format: date-time */
+                        executeAt: string;
+                    }[];
+                };
+            };
+            responses: {
+                /** @description Default Response */
+                202: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+                /** @description Default Response */
+                500: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            /** @description Code used to categorize the error */
+                            code: string;
+                            /** @description Description of the error */
+                            detail: string;
+                            /** @description Unique request id. This one will be used to troubleshoot the problems */
+                            requestId: string;
+                            /** @description Name of the error type */
+                            name: string;
+                            /** @description List of the validation errors */
+                            validation?: {
+                                fieldName: string;
+                                message: string;
+                            }[];
+                            validationContext?: string;
+                        };
+                    };
+                };
+            };
+        };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+}
+export type webhooks = Record<string, never>;
+export interface components {
+    schemas: never;
+    responses: never;
+    parameters: never;
+    requestBodies: never;
+    headers: never;
+    pathItems: never;
+}
+export type $defs = Record<string, never>;
+export type operations = Record<string, never>;

package/src/client/clients/upload/index.ts

@@ -0,0 +1,129 @@
+import type createClient from "openapi-fetch";
+import { UPLOAD } from "../../../types/index.js";
+import BaseClient from "../../base-client.js";
+import type { paths } from "./schema.js";
+
+class Upload extends BaseClient<paths> {
+  declare client: ReturnType<typeof createClient<paths>>;
+  protected serviceName = UPLOAD;
+
+  getFilesMetadata(organizationId: string) {
+    return this.client
+      .GET("/api/v1/metadata/", {
+        params: {
+          query: {
+            organizationId,
+          },
+        },
+      })
+      .then(
+        (response) => this.formatResponse(response),
+        (reason) => this.formatError(reason),
+      );
+  }
+
+  shareFile(fileId: string, userId: string) {
+    return this.client
+      .POST("/api/v1/permissions/", {
+        body: { fileId, userId },
+      })
+      .then(
+        (response) => this.formatResponse(response),
+        (reason) => this.formatError(reason),
+      );
+  }
+
+  removeFileSharing(fileId: string, userId: string) {
+    return this.client
+      .DELETE("/api/v1/permissions/", {
+        body: { fileId, userId },
+      })
+      .then(
+        (response) => this.formatResponse(response),
+        (reason) => this.formatError(reason),
+      );
+  }
+
+  async getFile(id: string) {
+    try {
+      const {
+        error,
+        data,
+        response: { headers, status },
+      } = await this.client.GET("/api/v1/files/{id}", {
+        params: { path: { id } },
+        parseAs: "stream",
+      });
+
+      return {
+        error,
+        data,
+        headers: Object.fromEntries(headers.entries()),
+        status,
+      };
+    } catch (e) {
+      return {
+        error: e,
+        data: null,
+        headers: null,
+        status: 500,
+      };
+    }
+  }
+
+  getSharedFilesForUser(userId: string) {
+    return this.client
+      .GET("/api/v1/metadata/", {
+        params: { query: { userId } },
+      })
+      .then(
+        (response) => this.formatResponse(response),
+        (reason) => this.formatError(reason),
+      );
+  }
+
+  getFileMetadata(id: string) {
+    return this.client
+      .GET("/api/v1/metadata/{id}", {
+        params: { path: { id } },
+      })
+      .then(
+        (response) => this.formatResponse(response),
+        (reason) => this.formatError(reason),
+      );
+  }
+
+  scheduleFileDeletion(id: string) {
+    return this.client
+      .DELETE("/api/v1/metadata/", {
+        body: { fileId: id },
+      })
+      .then(
+        (response) => this.formatResponse(response),
+        (reason) => this.formatError(reason),
+      );
+  }
+
+  async uploadFile(file: File, expirationDate?: string) {
+    const { error } = await this.client.POST("/api/v1/files/", {
+      body: {
+        file,
+        expirationDate,
+      },
+
+      bodySerializer: (body: unknown) => {
+        const pasrsed = body as { file: File; expirationDate: string };
+        const formData = new FormData();
+        if (pasrsed.expirationDate) {
+          formData.set("expirationDate", pasrsed.expirationDate);
+        }
+        formData.set("file", pasrsed.file);
+        return formData;
+      },
+    });
+
+    return { error };
+  }
+}
+
+export default Upload;