mirror of
https://github.com/LukeHagar/discoursejs.git
synced 2025-12-06 12:27:48 +00:00
749 lines
28 KiB
TypeScript
749 lines
28 KiB
TypeScript
/*
|
|
* Code generated by Speakeasy (https://speakeasyapi.dev). DO NOT EDIT.
|
|
*/
|
|
|
|
import * as utils from "../internal/utils";
|
|
import * as errors from "../sdk/models/errors";
|
|
import * as operations from "../sdk/models/operations";
|
|
import * as shared from "../sdk/models/shared";
|
|
import { SDKConfiguration } from "./sdk";
|
|
import { AxiosInstance, AxiosRequestConfig, AxiosResponse, RawAxiosRequestHeaders } from "axios";
|
|
|
|
export class Uploads {
|
|
private sdkConfiguration: SDKConfiguration;
|
|
|
|
constructor(sdkConfig: SDKConfiguration) {
|
|
this.sdkConfiguration = sdkConfig;
|
|
}
|
|
|
|
/**
|
|
* Abort multipart upload
|
|
*
|
|
* @remarks
|
|
* This endpoint aborts the multipart upload initiated with /create-multipart.
|
|
* This should be used when cancelling the upload. It does not matter if parts
|
|
* were already uploaded into the external storage provider.
|
|
*
|
|
* You must have the correct permissions and CORS settings configured in your
|
|
* external provider. We support AWS S3 as the default. See:
|
|
*
|
|
* https://meta.discourse.org/t/-/210469#s3-multipart-direct-uploads-4.
|
|
*
|
|
* An external file store must be set up and `enable_direct_s3_uploads` must
|
|
* be set to true for this endpoint to function.
|
|
*
|
|
*
|
|
*/
|
|
async abortMultipart(
|
|
req: operations.AbortMultipartRequestBody,
|
|
config?: AxiosRequestConfig
|
|
): Promise<operations.AbortMultipartResponse> {
|
|
if (!(req instanceof utils.SpeakeasyBase)) {
|
|
req = new operations.AbortMultipartRequestBody(req);
|
|
}
|
|
|
|
const baseURL: string = utils.templateUrl(
|
|
this.sdkConfiguration.serverURL,
|
|
this.sdkConfiguration.serverDefaults
|
|
);
|
|
const operationUrl: string = baseURL.replace(/\/$/, "") + "/uploads/abort-multipart.json";
|
|
|
|
let [reqBodyHeaders, reqBody]: [object, any] = [{}, null];
|
|
|
|
try {
|
|
[reqBodyHeaders, reqBody] = utils.serializeRequestBody(req, "request", "json");
|
|
} catch (e: unknown) {
|
|
if (e instanceof Error) {
|
|
throw new Error(`Error serializing request body, cause: ${e.message}`);
|
|
}
|
|
}
|
|
const client: AxiosInstance = this.sdkConfiguration.defaultClient;
|
|
let globalSecurity = this.sdkConfiguration.security;
|
|
if (typeof globalSecurity === "function") {
|
|
globalSecurity = await globalSecurity();
|
|
}
|
|
if (!(globalSecurity instanceof utils.SpeakeasyBase)) {
|
|
globalSecurity = new shared.Security(globalSecurity);
|
|
}
|
|
const properties = utils.parseSecurityProperties(globalSecurity);
|
|
const headers: RawAxiosRequestHeaders = {
|
|
...reqBodyHeaders,
|
|
...config?.headers,
|
|
...properties.headers,
|
|
};
|
|
headers["Accept"] = "application/json";
|
|
|
|
headers["user-agent"] = this.sdkConfiguration.userAgent;
|
|
|
|
const httpRes: AxiosResponse = await client.request({
|
|
validateStatus: () => true,
|
|
url: operationUrl,
|
|
method: "post",
|
|
headers: headers,
|
|
responseType: "arraybuffer",
|
|
data: reqBody,
|
|
...config,
|
|
});
|
|
|
|
const responseContentType: string = httpRes?.headers?.["content-type"] ?? "";
|
|
|
|
if (httpRes?.status == null) {
|
|
throw new Error(`status code not found in response: ${httpRes}`);
|
|
}
|
|
|
|
const res: operations.AbortMultipartResponse = new operations.AbortMultipartResponse({
|
|
statusCode: httpRes.status,
|
|
contentType: responseContentType,
|
|
rawResponse: httpRes,
|
|
});
|
|
const decodedRes = new TextDecoder().decode(httpRes?.data);
|
|
switch (true) {
|
|
case httpRes?.status == 200:
|
|
if (utils.matchContentType(responseContentType, `application/json`)) {
|
|
res.object = utils.objectToClass(
|
|
JSON.parse(decodedRes),
|
|
operations.AbortMultipartResponseBody
|
|
);
|
|
} else {
|
|
throw new errors.SDKError(
|
|
"unknown content-type received: " + responseContentType,
|
|
httpRes.status,
|
|
decodedRes,
|
|
httpRes
|
|
);
|
|
}
|
|
break;
|
|
}
|
|
|
|
return res;
|
|
}
|
|
|
|
/**
|
|
* Generates batches of presigned URLs for multipart parts
|
|
*
|
|
* @remarks
|
|
* Multipart uploads are uploaded in chunks or parts to individual presigned
|
|
* URLs, similar to the one generated by /generate-presigned-put. The part
|
|
* numbers provided must be between 1 and 10000. The total number of parts
|
|
* will depend on the chunk size in bytes that you intend to use to upload
|
|
* each chunk. For example a 12MB file may have 2 5MB chunks and a final
|
|
* 2MB chunk, for part numbers 1, 2, and 3.
|
|
*
|
|
* This endpoint will return a presigned URL for each part number provided,
|
|
* which you can then use to send PUT requests for the binary chunk corresponding
|
|
* to that part. When the part is uploaded, the provider should return an
|
|
* ETag for the part, and this should be stored along with the part number,
|
|
* because this is needed to complete the multipart upload.
|
|
*
|
|
* You must have the correct permissions and CORS settings configured in your
|
|
* external provider. We support AWS S3 as the default. See:
|
|
*
|
|
* https://meta.discourse.org/t/-/210469#s3-multipart-direct-uploads-4.
|
|
*
|
|
* An external file store must be set up and `enable_direct_s3_uploads` must
|
|
* be set to true for this endpoint to function.
|
|
*
|
|
*
|
|
*/
|
|
async batchPresignMultipartParts(
|
|
req: operations.BatchPresignMultipartPartsRequestBody,
|
|
config?: AxiosRequestConfig
|
|
): Promise<operations.BatchPresignMultipartPartsResponse> {
|
|
if (!(req instanceof utils.SpeakeasyBase)) {
|
|
req = new operations.BatchPresignMultipartPartsRequestBody(req);
|
|
}
|
|
|
|
const baseURL: string = utils.templateUrl(
|
|
this.sdkConfiguration.serverURL,
|
|
this.sdkConfiguration.serverDefaults
|
|
);
|
|
const operationUrl: string =
|
|
baseURL.replace(/\/$/, "") + "/uploads/batch-presign-multipart-parts.json";
|
|
|
|
let [reqBodyHeaders, reqBody]: [object, any] = [{}, null];
|
|
|
|
try {
|
|
[reqBodyHeaders, reqBody] = utils.serializeRequestBody(req, "request", "json");
|
|
} catch (e: unknown) {
|
|
if (e instanceof Error) {
|
|
throw new Error(`Error serializing request body, cause: ${e.message}`);
|
|
}
|
|
}
|
|
const client: AxiosInstance = this.sdkConfiguration.defaultClient;
|
|
let globalSecurity = this.sdkConfiguration.security;
|
|
if (typeof globalSecurity === "function") {
|
|
globalSecurity = await globalSecurity();
|
|
}
|
|
if (!(globalSecurity instanceof utils.SpeakeasyBase)) {
|
|
globalSecurity = new shared.Security(globalSecurity);
|
|
}
|
|
const properties = utils.parseSecurityProperties(globalSecurity);
|
|
const headers: RawAxiosRequestHeaders = {
|
|
...reqBodyHeaders,
|
|
...config?.headers,
|
|
...properties.headers,
|
|
};
|
|
headers["Accept"] = "application/json";
|
|
|
|
headers["user-agent"] = this.sdkConfiguration.userAgent;
|
|
|
|
const httpRes: AxiosResponse = await client.request({
|
|
validateStatus: () => true,
|
|
url: operationUrl,
|
|
method: "post",
|
|
headers: headers,
|
|
responseType: "arraybuffer",
|
|
data: reqBody,
|
|
...config,
|
|
});
|
|
|
|
const responseContentType: string = httpRes?.headers?.["content-type"] ?? "";
|
|
|
|
if (httpRes?.status == null) {
|
|
throw new Error(`status code not found in response: ${httpRes}`);
|
|
}
|
|
|
|
const res: operations.BatchPresignMultipartPartsResponse =
|
|
new operations.BatchPresignMultipartPartsResponse({
|
|
statusCode: httpRes.status,
|
|
contentType: responseContentType,
|
|
rawResponse: httpRes,
|
|
});
|
|
const decodedRes = new TextDecoder().decode(httpRes?.data);
|
|
switch (true) {
|
|
case httpRes?.status == 200:
|
|
if (utils.matchContentType(responseContentType, `application/json`)) {
|
|
res.object = utils.objectToClass(
|
|
JSON.parse(decodedRes),
|
|
operations.BatchPresignMultipartPartsResponseBody
|
|
);
|
|
} else {
|
|
throw new errors.SDKError(
|
|
"unknown content-type received: " + responseContentType,
|
|
httpRes.status,
|
|
decodedRes,
|
|
httpRes
|
|
);
|
|
}
|
|
break;
|
|
}
|
|
|
|
return res;
|
|
}
|
|
|
|
/**
|
|
* Completes a direct external upload
|
|
*
|
|
* @remarks
|
|
* Completes an external upload initialized with /get-presigned-put. The
|
|
* file will be moved from its temporary location in external storage to
|
|
* a final destination in the S3 bucket. An Upload record will also be
|
|
* created in the database in most cases.
|
|
*
|
|
* If a sha1-checksum was provided in the initial request it will also
|
|
* be compared with the uploaded file in storage to make sure the same
|
|
* file was uploaded. The file size will be compared for the same reason.
|
|
*
|
|
* You must have the correct permissions and CORS settings configured in your
|
|
* external provider. We support AWS S3 as the default. See:
|
|
*
|
|
* https://meta.discourse.org/t/-/210469#s3-multipart-direct-uploads-4.
|
|
*
|
|
* An external file store must be set up and `enable_direct_s3_uploads` must
|
|
* be set to true for this endpoint to function.
|
|
*
|
|
*
|
|
*/
|
|
async completeExternalUpload(
|
|
req: operations.CompleteExternalUploadRequestBody,
|
|
config?: AxiosRequestConfig
|
|
): Promise<operations.CompleteExternalUploadResponse> {
|
|
if (!(req instanceof utils.SpeakeasyBase)) {
|
|
req = new operations.CompleteExternalUploadRequestBody(req);
|
|
}
|
|
|
|
const baseURL: string = utils.templateUrl(
|
|
this.sdkConfiguration.serverURL,
|
|
this.sdkConfiguration.serverDefaults
|
|
);
|
|
const operationUrl: string =
|
|
baseURL.replace(/\/$/, "") + "/uploads/complete-external-upload.json";
|
|
|
|
let [reqBodyHeaders, reqBody]: [object, any] = [{}, null];
|
|
|
|
try {
|
|
[reqBodyHeaders, reqBody] = utils.serializeRequestBody(req, "request", "json");
|
|
} catch (e: unknown) {
|
|
if (e instanceof Error) {
|
|
throw new Error(`Error serializing request body, cause: ${e.message}`);
|
|
}
|
|
}
|
|
const client: AxiosInstance = this.sdkConfiguration.defaultClient;
|
|
let globalSecurity = this.sdkConfiguration.security;
|
|
if (typeof globalSecurity === "function") {
|
|
globalSecurity = await globalSecurity();
|
|
}
|
|
if (!(globalSecurity instanceof utils.SpeakeasyBase)) {
|
|
globalSecurity = new shared.Security(globalSecurity);
|
|
}
|
|
const properties = utils.parseSecurityProperties(globalSecurity);
|
|
const headers: RawAxiosRequestHeaders = {
|
|
...reqBodyHeaders,
|
|
...config?.headers,
|
|
...properties.headers,
|
|
};
|
|
headers["Accept"] = "application/json";
|
|
|
|
headers["user-agent"] = this.sdkConfiguration.userAgent;
|
|
|
|
const httpRes: AxiosResponse = await client.request({
|
|
validateStatus: () => true,
|
|
url: operationUrl,
|
|
method: "post",
|
|
headers: headers,
|
|
responseType: "arraybuffer",
|
|
data: reqBody,
|
|
...config,
|
|
});
|
|
|
|
const responseContentType: string = httpRes?.headers?.["content-type"] ?? "";
|
|
|
|
if (httpRes?.status == null) {
|
|
throw new Error(`status code not found in response: ${httpRes}`);
|
|
}
|
|
|
|
const res: operations.CompleteExternalUploadResponse =
|
|
new operations.CompleteExternalUploadResponse({
|
|
statusCode: httpRes.status,
|
|
contentType: responseContentType,
|
|
rawResponse: httpRes,
|
|
});
|
|
const decodedRes = new TextDecoder().decode(httpRes?.data);
|
|
switch (true) {
|
|
case httpRes?.status == 200:
|
|
if (utils.matchContentType(responseContentType, `application/json`)) {
|
|
res.object = utils.objectToClass(
|
|
JSON.parse(decodedRes),
|
|
operations.CompleteExternalUploadResponseBody
|
|
);
|
|
} else {
|
|
throw new errors.SDKError(
|
|
"unknown content-type received: " + responseContentType,
|
|
httpRes.status,
|
|
decodedRes,
|
|
httpRes
|
|
);
|
|
}
|
|
break;
|
|
}
|
|
|
|
return res;
|
|
}
|
|
|
|
/**
|
|
* Complete multipart upload
|
|
*
|
|
* @remarks
|
|
* Completes the multipart upload in the external store, and copies the
|
|
* file from its temporary location to its final location in the store.
|
|
* All of the parts must have been uploaded to the external storage provider.
|
|
* An Upload record will be completed in most cases once the file is copied
|
|
* to its final location.
|
|
*
|
|
* You must have the correct permissions and CORS settings configured in your
|
|
* external provider. We support AWS S3 as the default. See:
|
|
*
|
|
* https://meta.discourse.org/t/-/210469#s3-multipart-direct-uploads-4.
|
|
*
|
|
* An external file store must be set up and `enable_direct_s3_uploads` must
|
|
* be set to true for this endpoint to function.
|
|
*
|
|
*
|
|
*/
|
|
async completeMultipart(
|
|
req: operations.CompleteMultipartRequestBody,
|
|
config?: AxiosRequestConfig
|
|
): Promise<operations.CompleteMultipartResponse> {
|
|
if (!(req instanceof utils.SpeakeasyBase)) {
|
|
req = new operations.CompleteMultipartRequestBody(req);
|
|
}
|
|
|
|
const baseURL: string = utils.templateUrl(
|
|
this.sdkConfiguration.serverURL,
|
|
this.sdkConfiguration.serverDefaults
|
|
);
|
|
const operationUrl: string =
|
|
baseURL.replace(/\/$/, "") + "/uploads/complete-multipart.json";
|
|
|
|
let [reqBodyHeaders, reqBody]: [object, any] = [{}, null];
|
|
|
|
try {
|
|
[reqBodyHeaders, reqBody] = utils.serializeRequestBody(req, "request", "json");
|
|
} catch (e: unknown) {
|
|
if (e instanceof Error) {
|
|
throw new Error(`Error serializing request body, cause: ${e.message}`);
|
|
}
|
|
}
|
|
const client: AxiosInstance = this.sdkConfiguration.defaultClient;
|
|
let globalSecurity = this.sdkConfiguration.security;
|
|
if (typeof globalSecurity === "function") {
|
|
globalSecurity = await globalSecurity();
|
|
}
|
|
if (!(globalSecurity instanceof utils.SpeakeasyBase)) {
|
|
globalSecurity = new shared.Security(globalSecurity);
|
|
}
|
|
const properties = utils.parseSecurityProperties(globalSecurity);
|
|
const headers: RawAxiosRequestHeaders = {
|
|
...reqBodyHeaders,
|
|
...config?.headers,
|
|
...properties.headers,
|
|
};
|
|
headers["Accept"] = "application/json";
|
|
|
|
headers["user-agent"] = this.sdkConfiguration.userAgent;
|
|
|
|
const httpRes: AxiosResponse = await client.request({
|
|
validateStatus: () => true,
|
|
url: operationUrl,
|
|
method: "post",
|
|
headers: headers,
|
|
responseType: "arraybuffer",
|
|
data: reqBody,
|
|
...config,
|
|
});
|
|
|
|
const responseContentType: string = httpRes?.headers?.["content-type"] ?? "";
|
|
|
|
if (httpRes?.status == null) {
|
|
throw new Error(`status code not found in response: ${httpRes}`);
|
|
}
|
|
|
|
const res: operations.CompleteMultipartResponse = new operations.CompleteMultipartResponse({
|
|
statusCode: httpRes.status,
|
|
contentType: responseContentType,
|
|
rawResponse: httpRes,
|
|
});
|
|
const decodedRes = new TextDecoder().decode(httpRes?.data);
|
|
switch (true) {
|
|
case httpRes?.status == 200:
|
|
if (utils.matchContentType(responseContentType, `application/json`)) {
|
|
res.object = utils.objectToClass(
|
|
JSON.parse(decodedRes),
|
|
operations.CompleteMultipartResponseBody
|
|
);
|
|
} else {
|
|
throw new errors.SDKError(
|
|
"unknown content-type received: " + responseContentType,
|
|
httpRes.status,
|
|
decodedRes,
|
|
httpRes
|
|
);
|
|
}
|
|
break;
|
|
}
|
|
|
|
return res;
|
|
}
|
|
|
|
/**
|
|
* Creates a multipart external upload
|
|
*
|
|
* @remarks
|
|
* Creates a multipart upload in the external storage provider, storing
|
|
* a temporary reference to the external upload similar to /get-presigned-put.
|
|
*
|
|
* You must have the correct permissions and CORS settings configured in your
|
|
* external provider. We support AWS S3 as the default. See:
|
|
*
|
|
* https://meta.discourse.org/t/-/210469#s3-multipart-direct-uploads-4.
|
|
*
|
|
* An external file store must be set up and `enable_direct_s3_uploads` must
|
|
* be set to true for this endpoint to function.
|
|
*
|
|
*
|
|
*/
|
|
async createMultipartUpload(
|
|
req: operations.CreateMultipartUploadRequestBody,
|
|
config?: AxiosRequestConfig
|
|
): Promise<operations.CreateMultipartUploadResponse> {
|
|
if (!(req instanceof utils.SpeakeasyBase)) {
|
|
req = new operations.CreateMultipartUploadRequestBody(req);
|
|
}
|
|
|
|
const baseURL: string = utils.templateUrl(
|
|
this.sdkConfiguration.serverURL,
|
|
this.sdkConfiguration.serverDefaults
|
|
);
|
|
const operationUrl: string = baseURL.replace(/\/$/, "") + "/uploads/create-multipart.json";
|
|
|
|
let [reqBodyHeaders, reqBody]: [object, any] = [{}, null];
|
|
|
|
try {
|
|
[reqBodyHeaders, reqBody] = utils.serializeRequestBody(req, "request", "json");
|
|
} catch (e: unknown) {
|
|
if (e instanceof Error) {
|
|
throw new Error(`Error serializing request body, cause: ${e.message}`);
|
|
}
|
|
}
|
|
const client: AxiosInstance = this.sdkConfiguration.defaultClient;
|
|
let globalSecurity = this.sdkConfiguration.security;
|
|
if (typeof globalSecurity === "function") {
|
|
globalSecurity = await globalSecurity();
|
|
}
|
|
if (!(globalSecurity instanceof utils.SpeakeasyBase)) {
|
|
globalSecurity = new shared.Security(globalSecurity);
|
|
}
|
|
const properties = utils.parseSecurityProperties(globalSecurity);
|
|
const headers: RawAxiosRequestHeaders = {
|
|
...reqBodyHeaders,
|
|
...config?.headers,
|
|
...properties.headers,
|
|
};
|
|
headers["Accept"] = "application/json";
|
|
|
|
headers["user-agent"] = this.sdkConfiguration.userAgent;
|
|
|
|
const httpRes: AxiosResponse = await client.request({
|
|
validateStatus: () => true,
|
|
url: operationUrl,
|
|
method: "post",
|
|
headers: headers,
|
|
responseType: "arraybuffer",
|
|
data: reqBody,
|
|
...config,
|
|
});
|
|
|
|
const responseContentType: string = httpRes?.headers?.["content-type"] ?? "";
|
|
|
|
if (httpRes?.status == null) {
|
|
throw new Error(`status code not found in response: ${httpRes}`);
|
|
}
|
|
|
|
const res: operations.CreateMultipartUploadResponse =
|
|
new operations.CreateMultipartUploadResponse({
|
|
statusCode: httpRes.status,
|
|
contentType: responseContentType,
|
|
rawResponse: httpRes,
|
|
});
|
|
const decodedRes = new TextDecoder().decode(httpRes?.data);
|
|
switch (true) {
|
|
case httpRes?.status == 200:
|
|
if (utils.matchContentType(responseContentType, `application/json`)) {
|
|
res.object = utils.objectToClass(
|
|
JSON.parse(decodedRes),
|
|
operations.CreateMultipartUploadResponseBody
|
|
);
|
|
} else {
|
|
throw new errors.SDKError(
|
|
"unknown content-type received: " + responseContentType,
|
|
httpRes.status,
|
|
decodedRes,
|
|
httpRes
|
|
);
|
|
}
|
|
break;
|
|
}
|
|
|
|
return res;
|
|
}
|
|
|
|
/**
|
|
* Creates an upload
|
|
*/
|
|
async createUpload(
|
|
req: operations.CreateUploadRequestBody,
|
|
config?: AxiosRequestConfig
|
|
): Promise<operations.CreateUploadResponse> {
|
|
if (!(req instanceof utils.SpeakeasyBase)) {
|
|
req = new operations.CreateUploadRequestBody(req);
|
|
}
|
|
|
|
const baseURL: string = utils.templateUrl(
|
|
this.sdkConfiguration.serverURL,
|
|
this.sdkConfiguration.serverDefaults
|
|
);
|
|
const operationUrl: string = baseURL.replace(/\/$/, "") + "/uploads.json";
|
|
|
|
let [reqBodyHeaders, reqBody]: [object, any] = [{}, null];
|
|
|
|
try {
|
|
[reqBodyHeaders, reqBody] = utils.serializeRequestBody(req, "request", "multipart");
|
|
} catch (e: unknown) {
|
|
if (e instanceof Error) {
|
|
throw new Error(`Error serializing request body, cause: ${e.message}`);
|
|
}
|
|
}
|
|
const client: AxiosInstance = this.sdkConfiguration.defaultClient;
|
|
let globalSecurity = this.sdkConfiguration.security;
|
|
if (typeof globalSecurity === "function") {
|
|
globalSecurity = await globalSecurity();
|
|
}
|
|
if (!(globalSecurity instanceof utils.SpeakeasyBase)) {
|
|
globalSecurity = new shared.Security(globalSecurity);
|
|
}
|
|
const properties = utils.parseSecurityProperties(globalSecurity);
|
|
const headers: RawAxiosRequestHeaders = {
|
|
...reqBodyHeaders,
|
|
...config?.headers,
|
|
...properties.headers,
|
|
};
|
|
headers["Accept"] = "application/json";
|
|
|
|
headers["user-agent"] = this.sdkConfiguration.userAgent;
|
|
|
|
const httpRes: AxiosResponse = await client.request({
|
|
validateStatus: () => true,
|
|
url: operationUrl,
|
|
method: "post",
|
|
headers: headers,
|
|
responseType: "arraybuffer",
|
|
data: reqBody,
|
|
...config,
|
|
});
|
|
|
|
const responseContentType: string = httpRes?.headers?.["content-type"] ?? "";
|
|
|
|
if (httpRes?.status == null) {
|
|
throw new Error(`status code not found in response: ${httpRes}`);
|
|
}
|
|
|
|
const res: operations.CreateUploadResponse = new operations.CreateUploadResponse({
|
|
statusCode: httpRes.status,
|
|
contentType: responseContentType,
|
|
rawResponse: httpRes,
|
|
});
|
|
const decodedRes = new TextDecoder().decode(httpRes?.data);
|
|
switch (true) {
|
|
case httpRes?.status == 200:
|
|
if (utils.matchContentType(responseContentType, `application/json`)) {
|
|
res.object = utils.objectToClass(
|
|
JSON.parse(decodedRes),
|
|
operations.CreateUploadResponseBody
|
|
);
|
|
} else {
|
|
throw new errors.SDKError(
|
|
"unknown content-type received: " + responseContentType,
|
|
httpRes.status,
|
|
decodedRes,
|
|
httpRes
|
|
);
|
|
}
|
|
break;
|
|
}
|
|
|
|
return res;
|
|
}
|
|
|
|
/**
|
|
* Initiates a direct external upload
|
|
*
|
|
* @remarks
|
|
* Direct external uploads bypass the usual method of creating uploads
|
|
* via the POST /uploads route, and upload directly to an external provider,
|
|
* which by default is S3. This route begins the process, and will return
|
|
* a unique identifier for the external upload as well as a presigned URL
|
|
* which is where the file binary blob should be uploaded to.
|
|
*
|
|
* Once the upload is complete to the external service, you must call the
|
|
* POST /complete-external-upload route using the unique identifier returned
|
|
* by this route, which will create any required Upload record in the Discourse
|
|
* database and also move file from its temporary location to the final
|
|
* destination in the external storage service.
|
|
*
|
|
* You must have the correct permissions and CORS settings configured in your
|
|
* external provider. We support AWS S3 as the default. See:
|
|
*
|
|
* https://meta.discourse.org/t/-/210469#s3-multipart-direct-uploads-4.
|
|
*
|
|
* An external file store must be set up and `enable_direct_s3_uploads` must
|
|
* be set to true for this endpoint to function.
|
|
*
|
|
*
|
|
*/
|
|
async generatePresignedPut(
|
|
req: operations.GeneratePresignedPutRequestBody,
|
|
config?: AxiosRequestConfig
|
|
): Promise<operations.GeneratePresignedPutResponse> {
|
|
if (!(req instanceof utils.SpeakeasyBase)) {
|
|
req = new operations.GeneratePresignedPutRequestBody(req);
|
|
}
|
|
|
|
const baseURL: string = utils.templateUrl(
|
|
this.sdkConfiguration.serverURL,
|
|
this.sdkConfiguration.serverDefaults
|
|
);
|
|
const operationUrl: string =
|
|
baseURL.replace(/\/$/, "") + "/uploads/generate-presigned-put.json";
|
|
|
|
let [reqBodyHeaders, reqBody]: [object, any] = [{}, null];
|
|
|
|
try {
|
|
[reqBodyHeaders, reqBody] = utils.serializeRequestBody(req, "request", "json");
|
|
} catch (e: unknown) {
|
|
if (e instanceof Error) {
|
|
throw new Error(`Error serializing request body, cause: ${e.message}`);
|
|
}
|
|
}
|
|
const client: AxiosInstance = this.sdkConfiguration.defaultClient;
|
|
let globalSecurity = this.sdkConfiguration.security;
|
|
if (typeof globalSecurity === "function") {
|
|
globalSecurity = await globalSecurity();
|
|
}
|
|
if (!(globalSecurity instanceof utils.SpeakeasyBase)) {
|
|
globalSecurity = new shared.Security(globalSecurity);
|
|
}
|
|
const properties = utils.parseSecurityProperties(globalSecurity);
|
|
const headers: RawAxiosRequestHeaders = {
|
|
...reqBodyHeaders,
|
|
...config?.headers,
|
|
...properties.headers,
|
|
};
|
|
headers["Accept"] = "application/json";
|
|
|
|
headers["user-agent"] = this.sdkConfiguration.userAgent;
|
|
|
|
const httpRes: AxiosResponse = await client.request({
|
|
validateStatus: () => true,
|
|
url: operationUrl,
|
|
method: "post",
|
|
headers: headers,
|
|
responseType: "arraybuffer",
|
|
data: reqBody,
|
|
...config,
|
|
});
|
|
|
|
const responseContentType: string = httpRes?.headers?.["content-type"] ?? "";
|
|
|
|
if (httpRes?.status == null) {
|
|
throw new Error(`status code not found in response: ${httpRes}`);
|
|
}
|
|
|
|
const res: operations.GeneratePresignedPutResponse =
|
|
new operations.GeneratePresignedPutResponse({
|
|
statusCode: httpRes.status,
|
|
contentType: responseContentType,
|
|
rawResponse: httpRes,
|
|
});
|
|
const decodedRes = new TextDecoder().decode(httpRes?.data);
|
|
switch (true) {
|
|
case httpRes?.status == 200:
|
|
if (utils.matchContentType(responseContentType, `application/json`)) {
|
|
res.object = utils.objectToClass(
|
|
JSON.parse(decodedRes),
|
|
operations.GeneratePresignedPutResponseBody
|
|
);
|
|
} else {
|
|
throw new errors.SDKError(
|
|
"unknown content-type received: " + responseContentType,
|
|
httpRes.status,
|
|
decodedRes,
|
|
httpRes
|
|
);
|
|
}
|
|
break;
|
|
}
|
|
|
|
return res;
|
|
}
|
|
}
|