@datastax/astra-db-ts
Version:
Data API TypeScript client
225 lines (224 loc) • 11.8 kB
JavaScript
// Copyright Datastax, Inc
// SPDX-License-Identifier: Apache-2.0
// noinspection ExceptionCaughtLocallyJS
var _AstraAdmin_defaultOpts, _AstraAdmin_httpClient, _AstraAdmin_environment;
import { __classPrivateFieldGet, __classPrivateFieldSet } from "tslib";
import { AstraDbAdmin } from '../administration/astra-db-admin.js';
import { Db } from '../db/db.js';
import { buildAstraDatabaseAdminInfo, buildAstraPCUTypeDescriptor, idFromDbLike } from '../administration/utils.js';
import { DEFAULT_DEVOPS_API_ENDPOINTS, DEFAULT_KEYSPACE, HttpMethods } from '../lib/api/constants.js';
import { DevOpsAPIHttpClient } from '../lib/api/clients/devops-api-http-client.js';
import { HierarchicalLogger, TokenProvider } from '../lib/index.js';
import { buildAstraEndpoint } from '../lib/utils.js';
import { $CustomInspect } from '../lib/constants.js';
import { Timeouts } from '../lib/api/timeouts/timeouts.js';
import { AdminOptsHandler } from '../client/opts-handlers/admin-opts-handler.js';
import { DbOptsHandler } from '../client/opts-handlers/db-opts-handler.js';
export class AstraAdmin extends HierarchicalLogger {
constructor(rootOpts, adminOpts) {
const defaultOpts = {
...rootOpts,
adminOptions: AdminOptsHandler.concat([rootOpts.adminOptions, adminOpts]),
dbOptions: {
...rootOpts.dbOptions,
token: TokenProvider.opts.concat([rootOpts.adminOptions.adminToken, adminOpts?.adminToken, rootOpts.dbOptions.token]),
},
};
super(rootOpts.client, defaultOpts.adminOptions.logging);
_AstraAdmin_defaultOpts.set(this, void 0);
_AstraAdmin_httpClient.set(this, void 0);
_AstraAdmin_environment.set(this, void 0);
__classPrivateFieldSet(this, _AstraAdmin_defaultOpts, defaultOpts, "f");
__classPrivateFieldSet(this, _AstraAdmin_environment, __classPrivateFieldGet(this, _AstraAdmin_defaultOpts, "f").adminOptions.astraEnv ?? 'prod', "f");
__classPrivateFieldSet(this, _AstraAdmin_httpClient, new DevOpsAPIHttpClient({
baseUrl: __classPrivateFieldGet(this, _AstraAdmin_defaultOpts, "f").adminOptions.endpointUrl ?? DEFAULT_DEVOPS_API_ENDPOINTS[__classPrivateFieldGet(this, _AstraAdmin_environment, "f")],
logger: this,
fetchCtx: rootOpts.fetchCtx,
caller: rootOpts.caller,
tokenProvider: __classPrivateFieldGet(this, _AstraAdmin_defaultOpts, "f").adminOptions.adminToken,
additionalHeaders: __classPrivateFieldGet(this, _AstraAdmin_defaultOpts, "f").additionalHeaders,
timeoutDefaults: Timeouts.cfg.concat([rootOpts.adminOptions.timeoutDefaults, __classPrivateFieldGet(this, _AstraAdmin_defaultOpts, "f").adminOptions.timeoutDefaults]),
}), "f");
Object.defineProperty(this, $CustomInspect, {
value: () => 'AstraAdmin()',
});
}
db(endpointOrId, regionOrOptions, maybeOptions) {
const [endpoint, dbOpts] = resolveEndpointOrIdOverload(endpointOrId, regionOrOptions, maybeOptions);
return new Db(__classPrivateFieldGet(this, _AstraAdmin_defaultOpts, "f"), endpoint, DbOptsHandler.parse(dbOpts));
}
dbAdmin(endpointOrId, regionOrOptions, maybeOptions) {
const [endpoint, dbOpts] = resolveEndpointOrIdOverload(endpointOrId, regionOrOptions, maybeOptions);
return new AstraDbAdmin(this.db(endpoint, dbOpts), __classPrivateFieldGet(this, _AstraAdmin_defaultOpts, "f"), AdminOptsHandler.empty, __classPrivateFieldGet(this, _AstraAdmin_defaultOpts, "f").dbOptions.token, endpoint);
}
async dbInfo(id, options) {
const tm = __classPrivateFieldGet(this, _AstraAdmin_httpClient, "f").tm.single('databaseAdminTimeoutMs', options);
const resp = await __classPrivateFieldGet(this, _AstraAdmin_httpClient, "f").request({
method: HttpMethods.Get,
path: `/databases/${id}`,
methodName: 'admin.dbInfo',
}, tm);
return buildAstraDatabaseAdminInfo(resp.data, __classPrivateFieldGet(this, _AstraAdmin_environment, "f"));
}
async listDatabases(options) {
const params = {};
if (typeof options?.include === 'string') {
params.include = options.include;
}
if (typeof options?.provider === 'string') {
params.provider = options.provider;
}
if (typeof options?.limit === 'number') {
params.limit = String(options.limit);
}
if (typeof options?.startingAfter === 'string') {
params.starting_after = options.startingAfter;
}
const tm = __classPrivateFieldGet(this, _AstraAdmin_httpClient, "f").tm.single('databaseAdminTimeoutMs', options);
const resp = await __classPrivateFieldGet(this, _AstraAdmin_httpClient, "f").request({
method: HttpMethods.Get,
path: `/databases`,
params: params,
methodName: 'admin.listDatabases',
}, tm);
return resp.data.map((d) => buildAstraDatabaseAdminInfo(d, __classPrivateFieldGet(this, _AstraAdmin_environment, "f")));
}
async createDatabase(nameOrConfig, configOrOptions, maybeOptions) {
let config;
let options;
if (typeof nameOrConfig === 'string') {
config = {
...configOrOptions,
name: nameOrConfig,
};
options = maybeOptions;
}
else {
config = nameOrConfig;
options = configOrOptions;
}
const definition = {
capacityUnits: 1,
tier: 'serverless',
dbType: 'vector',
keyspace: config.keyspace || DEFAULT_KEYSPACE,
...config,
};
if (definition.dbType === 'nonvector') {
delete definition.dbType;
}
if (definition.pcuGroupUUID) {
await this._validatePCUGroupExists(options, definition);
}
const tm = __classPrivateFieldGet(this, _AstraAdmin_httpClient, "f").tm.multipart('databaseAdminTimeoutMs', options);
const resp = await __classPrivateFieldGet(this, _AstraAdmin_httpClient, "f").requestLongRunning({
method: HttpMethods.Post,
path: '/databases',
data: definition,
methodName: 'admin.createDatabase',
}, {
id: (resp) => resp.headers.location,
target: 'ACTIVE',
legalStates: ['INITIALIZING', 'PENDING', 'ASSOCIATING'],
defaultPollInterval: 10000,
timeoutManager: tm,
options,
});
const endpoint = buildAstraEndpoint(resp.headers.location, definition.region);
const db = this.db(endpoint, { ...options?.dbOptions, keyspace: definition.keyspace });
return new AstraDbAdmin(db, __classPrivateFieldGet(this, _AstraAdmin_defaultOpts, "f"), AdminOptsHandler.empty, __classPrivateFieldGet(this, _AstraAdmin_defaultOpts, "f").adminOptions.adminToken, endpoint);
}
async _validatePCUGroupExists(options, definition) {
try {
const groups = await this.listPCUGroups({ timeout: options?.timeout }); // technically this should use a multi-call tm but honestly it probably doesn't matter
const group = groups.find(g => g.id === definition.pcuGroupUUID);
if (!group) {
throw new Error(`Requested PCU Group ID '${definition.pcuGroupUUID}' not found for cloud provider/region ('${definition.cloudProvider}' / '${definition.region}'). Aborting database creation.`);
}
if (group.cloudProvider.toLowerCase() !== definition.cloudProvider.toLowerCase() || group.region.toLowerCase() !== definition.region.toLowerCase()) {
throw new Error(`Requested PCU Group ID '${definition.pcuGroupUUID}' is in another cloud provider and region ('${group.cloudProvider}' / '${group.region}'). Aborting database creation.`);
}
}
catch (e) {
if (e instanceof Error)
throw e;
return;
}
}
async dropDatabase(db, options) {
const id = idFromDbLike(db);
const tm = __classPrivateFieldGet(this, _AstraAdmin_httpClient, "f").tm.multipart('databaseAdminTimeoutMs', options);
await __classPrivateFieldGet(this, _AstraAdmin_httpClient, "f").requestLongRunning({
method: HttpMethods.Post,
path: `/databases/${id}/terminate`,
methodName: 'admin.dropDatabase',
}, {
id: id,
target: 'TERMINATED',
legalStates: ['TERMINATING'],
defaultPollInterval: 10000,
timeoutManager: tm,
options,
});
}
async findAvailableRegions(options) {
const tm = __classPrivateFieldGet(this, _AstraAdmin_httpClient, "f").tm.single('databaseAdminTimeoutMs', options);
const filterByOrg = options?.onlyOrgEnabledRegions !== false ? 'enabled' : 'disabled';
const resp = await __classPrivateFieldGet(this, _AstraAdmin_httpClient, "f").request({
method: HttpMethods.Get,
path: '/regions/serverless',
params: {
'filter-by-org': filterByOrg,
'region-type': 'vector',
},
methodName: 'admin.findAvailableRegions',
}, tm);
return resp.data.map((region) => ({
classification: region.classification,
cloudProvider: region.cloudProvider,
displayName: region.displayName,
enabled: region.enabled,
name: region.name,
reservedForQualifiedUsers: region.reservedForQualifiedUsers,
zone: region.zone,
pcuTypes: region.pcu_types?.map(buildAstraPCUTypeDescriptor),
}));
}
async listPCUGroups(options) {
if (options?.region !== undefined && options?.cloudProvider === undefined) {
throw new Error("If 'region' is provided, 'cloudProvider' must also be provided.");
}
const tm = __classPrivateFieldGet(this, _AstraAdmin_httpClient, "f").tm.single('databaseAdminTimeoutMs', options);
const resp = await __classPrivateFieldGet(this, _AstraAdmin_httpClient, "f").request({
method: HttpMethods.Post,
path: '/pcus/actions/get',
data: {},
methodName: 'admin.listPCUGroups',
}, tm);
const pcuGroups = resp.data.map((pg) => ({
...pg,
pcuType: pg.pcuType ? buildAstraPCUTypeDescriptor(pg.pcuType) : undefined,
}));
if (options?.cloudProvider) {
return pcuGroups.filter(pg => pg.cloudProvider.toLowerCase() === options.cloudProvider.toLowerCase() &&
(!options.region || pg.region.toLowerCase() === options.region.toLowerCase()));
}
return pcuGroups;
}
get _httpClient() {
return __classPrivateFieldGet(this, _AstraAdmin_httpClient, "f");
}
}
_AstraAdmin_defaultOpts = new WeakMap(), _AstraAdmin_httpClient = new WeakMap(), _AstraAdmin_environment = new WeakMap();
const resolveEndpointOrIdOverload = (endpointOrId, regionOrOptions, maybeOptions) => {
const dbOpts = (typeof regionOrOptions === 'string')
? maybeOptions
: regionOrOptions;
if (typeof regionOrOptions === 'string' && (endpointOrId.startsWith('http'))) {
throw new Error('Unexpected db() argument: database id can\'t start with "http(s)://". Did you mean to call `.db(endpoint, { keyspace })`?');
}
const endpoint = (typeof regionOrOptions === 'string')
? 'https://' + endpointOrId + '-' + regionOrOptions + '.apps.astra.datastax.com'
: endpointOrId;
return [endpoint, dbOpts];
};