@datastax/astra-db-ts
Version:
Data API TypeScript client
167 lines (166 loc) • 8.95 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 } 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(config, options) {
const definition = {
capacityUnits: 1,
tier: 'serverless',
dbType: 'vector',
keyspace: config.keyspace || DEFAULT_KEYSPACE,
...config,
};
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'],
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 dropDatabase(db, options) {
const id = typeof db === 'string' ? db : db.id;
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,
}));
}
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];
};