forked from dienianindya/gsi_ess_mobile
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
482 lines
19 KiB
482 lines
19 KiB
"use strict";
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.getExtension = exports.deleteExtension = exports.unpublishExtension = exports.publishExtensionVersion = exports.undeprecateExtensionVersion = exports.deprecateExtensionVersion = exports.registerPublisherProfile = exports.getPublisherProfile = exports.listExtensionVersions = exports.listExtensions = exports.getExtensionVersion = exports.getSource = exports.createSource = exports.updateInstanceFromRegistry = exports.updateInstance = exports.configureInstance = exports.listInstances = exports.getInstance = exports.deleteInstance = exports.createInstance = void 0;
|
|
const yaml = require("js-yaml");
|
|
const clc = require("colorette");
|
|
const { marked } = require("marked");
|
|
const apiv2_1 = require("../apiv2");
|
|
const api_1 = require("../api");
|
|
const error_1 = require("../error");
|
|
const logger_1 = require("../logger");
|
|
const operationPoller = require("../operation-poller");
|
|
const refs = require("./refs");
|
|
const VERSION = "v1beta";
|
|
const PAGE_SIZE_MAX = 100;
|
|
const apiClient = new apiv2_1.Client({ urlPrefix: api_1.extensionsOrigin, apiVersion: VERSION });
|
|
async function createInstanceHelper(projectId, instanceId, config, validateOnly = false) {
|
|
const createRes = await apiClient.post(`/projects/${projectId}/instances/`, {
|
|
name: `projects/${projectId}/instances/${instanceId}`,
|
|
config,
|
|
}, {
|
|
queryParams: {
|
|
validateOnly: validateOnly ? "true" : "false",
|
|
},
|
|
});
|
|
if (validateOnly) {
|
|
return createRes.body;
|
|
}
|
|
const pollRes = await operationPoller.pollOperation({
|
|
apiOrigin: api_1.extensionsOrigin,
|
|
apiVersion: VERSION,
|
|
operationResourceName: createRes.body.name,
|
|
masterTimeout: 600000,
|
|
});
|
|
return pollRes;
|
|
}
|
|
async function createInstance(args) {
|
|
var _a, _b, _c;
|
|
const config = {
|
|
params: args.params,
|
|
systemParams: (_a = args.systemParams) !== null && _a !== void 0 ? _a : {},
|
|
allowedEventTypes: args.allowedEventTypes,
|
|
eventarcChannel: args.eventarcChannel,
|
|
};
|
|
if (args.extensionSource && args.extensionVersionRef) {
|
|
throw new error_1.FirebaseError("ExtensionSource and ExtensionVersion both provided, but only one should be.");
|
|
}
|
|
else if (args.extensionSource) {
|
|
config.source = { name: (_b = args.extensionSource) === null || _b === void 0 ? void 0 : _b.name };
|
|
}
|
|
else if (args.extensionVersionRef) {
|
|
const ref = refs.parse(args.extensionVersionRef);
|
|
config.extensionRef = refs.toExtensionRef(ref);
|
|
config.extensionVersion = (_c = ref.version) !== null && _c !== void 0 ? _c : "";
|
|
}
|
|
else {
|
|
throw new error_1.FirebaseError("No ExtensionVersion or ExtensionSource provided but one is required.");
|
|
}
|
|
if (args.allowedEventTypes) {
|
|
config.allowedEventTypes = args.allowedEventTypes;
|
|
}
|
|
if (args.eventarcChannel) {
|
|
config.eventarcChannel = args.eventarcChannel;
|
|
}
|
|
return createInstanceHelper(args.projectId, args.instanceId, config, args.validateOnly);
|
|
}
|
|
exports.createInstance = createInstance;
|
|
async function deleteInstance(projectId, instanceId) {
|
|
const deleteRes = await apiClient.delete(`/projects/${projectId}/instances/${instanceId}`);
|
|
const pollRes = await operationPoller.pollOperation({
|
|
apiOrigin: api_1.extensionsOrigin,
|
|
apiVersion: VERSION,
|
|
operationResourceName: deleteRes.body.name,
|
|
masterTimeout: 600000,
|
|
});
|
|
return pollRes;
|
|
}
|
|
exports.deleteInstance = deleteInstance;
|
|
async function getInstance(projectId, instanceId) {
|
|
try {
|
|
const res = await apiClient.get(`/projects/${projectId}/instances/${instanceId}`);
|
|
return res.body;
|
|
}
|
|
catch (err) {
|
|
if (err.status === 404) {
|
|
throw new error_1.FirebaseError(`Extension instance '${clc.bold(instanceId)}' not found in project '${clc.bold(projectId)}'.`, { status: 404 });
|
|
}
|
|
throw err;
|
|
}
|
|
}
|
|
exports.getInstance = getInstance;
|
|
async function listInstances(projectId) {
|
|
const instances = [];
|
|
const getNextPage = async (pageToken = "") => {
|
|
const res = await apiClient.get(`/projects/${projectId}/instances`, {
|
|
queryParams: {
|
|
pageSize: PAGE_SIZE_MAX,
|
|
pageToken,
|
|
},
|
|
});
|
|
if (Array.isArray(res.body.instances)) {
|
|
instances.push(...res.body.instances);
|
|
}
|
|
if (res.body.nextPageToken) {
|
|
await getNextPage(res.body.nextPageToken);
|
|
}
|
|
};
|
|
await getNextPage();
|
|
return instances;
|
|
}
|
|
exports.listInstances = listInstances;
|
|
async function configureInstance(args) {
|
|
var _a;
|
|
const reqBody = {
|
|
projectId: args.projectId,
|
|
instanceId: args.instanceId,
|
|
updateMask: "config.params",
|
|
validateOnly: (_a = args.validateOnly) !== null && _a !== void 0 ? _a : false,
|
|
data: {
|
|
config: {
|
|
params: args.params,
|
|
},
|
|
},
|
|
};
|
|
if (args.canEmitEvents) {
|
|
if (args.allowedEventTypes === undefined || args.eventarcChannel === undefined) {
|
|
throw new error_1.FirebaseError(`This instance is configured to emit events, but either allowed event types or eventarc channel is undefined.`);
|
|
}
|
|
reqBody.data.config.allowedEventTypes = args.allowedEventTypes;
|
|
reqBody.data.config.eventarcChannel = args.eventarcChannel;
|
|
}
|
|
reqBody.updateMask += ",config.allowed_event_types,config.eventarc_channel";
|
|
if (args.systemParams) {
|
|
reqBody.data.config.systemParams = args.systemParams;
|
|
reqBody.updateMask += ",config.system_params";
|
|
}
|
|
return patchInstance(reqBody);
|
|
}
|
|
exports.configureInstance = configureInstance;
|
|
async function updateInstance(args) {
|
|
var _a;
|
|
const body = {
|
|
config: {
|
|
source: { name: args.extensionSource.name },
|
|
},
|
|
};
|
|
let updateMask = "config.source.name";
|
|
if (args.params) {
|
|
body.config.params = args.params;
|
|
updateMask += ",config.params";
|
|
}
|
|
if (args.systemParams) {
|
|
body.config.systemParams = args.systemParams;
|
|
updateMask += ",config.system_params";
|
|
}
|
|
if (args.canEmitEvents) {
|
|
if (args.allowedEventTypes === undefined || args.eventarcChannel === undefined) {
|
|
throw new error_1.FirebaseError(`This instance is configured to emit events, but either allowed event types or eventarc channel is undefined.`);
|
|
}
|
|
body.config.allowedEventTypes = args.allowedEventTypes;
|
|
body.config.eventarcChannel = args.eventarcChannel;
|
|
}
|
|
updateMask += ",config.allowed_event_types,config.eventarc_channel";
|
|
return patchInstance({
|
|
projectId: args.projectId,
|
|
instanceId: args.instanceId,
|
|
updateMask,
|
|
validateOnly: (_a = args.validateOnly) !== null && _a !== void 0 ? _a : false,
|
|
data: body,
|
|
});
|
|
}
|
|
exports.updateInstance = updateInstance;
|
|
async function updateInstanceFromRegistry(args) {
|
|
var _a;
|
|
const ref = refs.parse(args.extRef);
|
|
const body = {
|
|
config: {
|
|
extensionRef: refs.toExtensionRef(ref),
|
|
extensionVersion: ref.version,
|
|
},
|
|
};
|
|
let updateMask = "config.extension_ref,config.extension_version";
|
|
if (args.params) {
|
|
body.config.params = args.params;
|
|
updateMask += ",config.params";
|
|
}
|
|
if (args.systemParams) {
|
|
body.config.systemParams = args.systemParams;
|
|
updateMask += ",config.system_params";
|
|
}
|
|
if (args.canEmitEvents) {
|
|
if (args.allowedEventTypes === undefined || args.eventarcChannel === undefined) {
|
|
throw new error_1.FirebaseError(`This instance is configured to emit events, but either allowed event types or eventarc channel is undefined.`);
|
|
}
|
|
body.config.allowedEventTypes = args.allowedEventTypes;
|
|
body.config.eventarcChannel = args.eventarcChannel;
|
|
}
|
|
updateMask += ",config.allowed_event_types,config.eventarc_channel";
|
|
return patchInstance({
|
|
projectId: args.projectId,
|
|
instanceId: args.instanceId,
|
|
updateMask,
|
|
validateOnly: (_a = args.validateOnly) !== null && _a !== void 0 ? _a : false,
|
|
data: body,
|
|
});
|
|
}
|
|
exports.updateInstanceFromRegistry = updateInstanceFromRegistry;
|
|
async function patchInstance(args) {
|
|
const updateRes = await apiClient.patch(`/projects/${args.projectId}/instances/${args.instanceId}`, args.data, {
|
|
queryParams: {
|
|
updateMask: args.updateMask,
|
|
validateOnly: args.validateOnly ? "true" : "false",
|
|
},
|
|
});
|
|
if (args.validateOnly) {
|
|
return updateRes;
|
|
}
|
|
const pollRes = await operationPoller.pollOperation({
|
|
apiOrigin: api_1.extensionsOrigin,
|
|
apiVersion: VERSION,
|
|
operationResourceName: updateRes.body.name,
|
|
masterTimeout: 600000,
|
|
});
|
|
return pollRes;
|
|
}
|
|
function populateResourceProperties(spec) {
|
|
if (spec) {
|
|
spec.resources.forEach((r) => {
|
|
try {
|
|
if (r.propertiesYaml) {
|
|
r.properties = yaml.safeLoad(r.propertiesYaml);
|
|
}
|
|
}
|
|
catch (err) {
|
|
logger_1.logger.debug(`[ext] failed to parse resource properties yaml: ${err}`);
|
|
}
|
|
});
|
|
}
|
|
}
|
|
async function createSource(projectId, packageUri, extensionRoot) {
|
|
const createRes = await apiClient.post(`/projects/${projectId}/sources/`, {
|
|
packageUri,
|
|
extensionRoot,
|
|
});
|
|
const pollRes = await operationPoller.pollOperation({
|
|
apiOrigin: api_1.extensionsOrigin,
|
|
apiVersion: VERSION,
|
|
operationResourceName: createRes.body.name,
|
|
masterTimeout: 600000,
|
|
});
|
|
if (pollRes.spec) {
|
|
populateResourceProperties(pollRes.spec);
|
|
}
|
|
return pollRes;
|
|
}
|
|
exports.createSource = createSource;
|
|
async function getSource(sourceName) {
|
|
const res = await apiClient.get(`/${sourceName}`);
|
|
if (res.body.spec) {
|
|
populateResourceProperties(res.body.spec);
|
|
}
|
|
return res.body;
|
|
}
|
|
exports.getSource = getSource;
|
|
async function getExtensionVersion(extensionVersionRef) {
|
|
const ref = refs.parse(extensionVersionRef);
|
|
if (!ref.version) {
|
|
throw new error_1.FirebaseError(`ExtensionVersion ref "${extensionVersionRef}" must supply a version.`);
|
|
}
|
|
try {
|
|
const res = await apiClient.get(`/${refs.toExtensionVersionName(ref)}`);
|
|
if (res.body.spec) {
|
|
populateResourceProperties(res.body.spec);
|
|
}
|
|
return res.body;
|
|
}
|
|
catch (err) {
|
|
if (err.status === 404) {
|
|
throw refNotFoundError(ref);
|
|
}
|
|
else if (err instanceof error_1.FirebaseError) {
|
|
throw err;
|
|
}
|
|
throw new error_1.FirebaseError(`Failed to query the extension version '${clc.bold(extensionVersionRef)}': ${err}`);
|
|
}
|
|
}
|
|
exports.getExtensionVersion = getExtensionVersion;
|
|
async function listExtensions(publisherId) {
|
|
const extensions = [];
|
|
const getNextPage = async (pageToken = "") => {
|
|
const res = await apiClient.get(`/publishers/${publisherId}/extensions`, {
|
|
queryParams: {
|
|
pageSize: PAGE_SIZE_MAX,
|
|
pageToken,
|
|
},
|
|
});
|
|
if (Array.isArray(res.body.extensions)) {
|
|
extensions.push(...res.body.extensions);
|
|
}
|
|
if (res.body.nextPageToken) {
|
|
await getNextPage(res.body.nextPageToken);
|
|
}
|
|
};
|
|
await getNextPage();
|
|
return extensions;
|
|
}
|
|
exports.listExtensions = listExtensions;
|
|
async function listExtensionVersions(ref, filter = "", showPrereleases = false) {
|
|
const { publisherId, extensionId } = refs.parse(ref);
|
|
const extensionVersions = [];
|
|
const getNextPage = async (pageToken = "") => {
|
|
const res = await apiClient.get(`/publishers/${publisherId}/extensions/${extensionId}/versions`, {
|
|
queryParams: {
|
|
filter,
|
|
showPrereleases: String(showPrereleases),
|
|
pageSize: PAGE_SIZE_MAX,
|
|
pageToken,
|
|
},
|
|
});
|
|
if (Array.isArray(res.body.extensionVersions)) {
|
|
extensionVersions.push(...res.body.extensionVersions);
|
|
}
|
|
if (res.body.nextPageToken) {
|
|
await getNextPage(res.body.nextPageToken);
|
|
}
|
|
};
|
|
await getNextPage();
|
|
return extensionVersions;
|
|
}
|
|
exports.listExtensionVersions = listExtensionVersions;
|
|
async function getPublisherProfile(projectId, publisherId) {
|
|
const res = await apiClient.get(`/projects/${projectId}/publisherProfile`, {
|
|
queryParams: publisherId === undefined
|
|
? undefined
|
|
: {
|
|
publisherId,
|
|
},
|
|
});
|
|
return res.body;
|
|
}
|
|
exports.getPublisherProfile = getPublisherProfile;
|
|
async function registerPublisherProfile(projectId, publisherId) {
|
|
const res = await apiClient.post(`/projects/${projectId}/publisherProfile:register`, {
|
|
publisherId,
|
|
});
|
|
return res.body;
|
|
}
|
|
exports.registerPublisherProfile = registerPublisherProfile;
|
|
async function deprecateExtensionVersion(extensionRef, deprecationMessage) {
|
|
const ref = refs.parse(extensionRef);
|
|
try {
|
|
const res = await apiClient.post(`/${refs.toExtensionVersionName(ref)}:deprecate`, {
|
|
deprecationMessage,
|
|
});
|
|
return res.body;
|
|
}
|
|
catch (err) {
|
|
if (err.status === 403) {
|
|
throw new error_1.FirebaseError(`You are not the owner of extension '${clc.bold(extensionRef)}' and don’t have the correct permissions to deprecate this extension version.` + err, { status: err.status });
|
|
}
|
|
else if (err.status === 404) {
|
|
throw new error_1.FirebaseError(`Extension version ${clc.bold(extensionRef)} was not found.`);
|
|
}
|
|
else if (err instanceof error_1.FirebaseError) {
|
|
throw err;
|
|
}
|
|
throw new error_1.FirebaseError(`Error occurred deprecating extension version '${extensionRef}': ${err}`, {
|
|
status: err.status,
|
|
});
|
|
}
|
|
}
|
|
exports.deprecateExtensionVersion = deprecateExtensionVersion;
|
|
async function undeprecateExtensionVersion(extensionRef) {
|
|
const ref = refs.parse(extensionRef);
|
|
try {
|
|
const res = await apiClient.post(`/${refs.toExtensionVersionName(ref)}:undeprecate`);
|
|
return res.body;
|
|
}
|
|
catch (err) {
|
|
if (err.status === 403) {
|
|
throw new error_1.FirebaseError(`You are not the owner of extension '${clc.bold(extensionRef)}' and don’t have the correct permissions to undeprecate this extension version.`, { status: err.status });
|
|
}
|
|
else if (err.status === 404) {
|
|
throw new error_1.FirebaseError(`Extension version ${clc.bold(extensionRef)} was not found.`);
|
|
}
|
|
else if (err instanceof error_1.FirebaseError) {
|
|
throw err;
|
|
}
|
|
throw new error_1.FirebaseError(`Error occurred undeprecating extension version '${extensionRef}': ${err}`, {
|
|
status: err.status,
|
|
});
|
|
}
|
|
}
|
|
exports.undeprecateExtensionVersion = undeprecateExtensionVersion;
|
|
async function publishExtensionVersion(extensionVersionRef, packageUri, extensionRoot) {
|
|
const ref = refs.parse(extensionVersionRef);
|
|
if (!ref.version) {
|
|
throw new error_1.FirebaseError(`ExtensionVersion ref "${extensionVersionRef}" must supply a version.`);
|
|
}
|
|
const publishRes = await apiClient.post(`/${refs.toExtensionName(ref)}/versions:publish`, {
|
|
versionId: ref.version,
|
|
packageUri,
|
|
extensionRoot: extensionRoot !== null && extensionRoot !== void 0 ? extensionRoot : "/",
|
|
});
|
|
const pollRes = await operationPoller.pollOperation({
|
|
apiOrigin: api_1.extensionsOrigin,
|
|
apiVersion: VERSION,
|
|
operationResourceName: publishRes.body.name,
|
|
masterTimeout: 600000,
|
|
});
|
|
return pollRes;
|
|
}
|
|
exports.publishExtensionVersion = publishExtensionVersion;
|
|
async function unpublishExtension(extensionRef) {
|
|
const ref = refs.parse(extensionRef);
|
|
if (ref.version) {
|
|
throw new error_1.FirebaseError(`Extension reference "${extensionRef}" must not contain a version.`);
|
|
}
|
|
try {
|
|
await apiClient.post(`/${refs.toExtensionName(ref)}:unpublish`);
|
|
}
|
|
catch (err) {
|
|
if (err.status === 403) {
|
|
throw new error_1.FirebaseError(`You are not the owner of extension '${clc.bold(extensionRef)}' and don’t have the correct permissions to unpublish this extension.`, { status: err.status });
|
|
}
|
|
else if (err instanceof error_1.FirebaseError) {
|
|
throw err;
|
|
}
|
|
throw new error_1.FirebaseError(`Error occurred unpublishing extension '${extensionRef}': ${err}`, {
|
|
status: err.status,
|
|
});
|
|
}
|
|
}
|
|
exports.unpublishExtension = unpublishExtension;
|
|
async function deleteExtension(extensionRef) {
|
|
const ref = refs.parse(extensionRef);
|
|
if (ref.version) {
|
|
throw new error_1.FirebaseError(`Extension reference "${extensionRef}" must not contain a version.`);
|
|
}
|
|
try {
|
|
await apiClient.delete(`/${refs.toExtensionName(ref)}`);
|
|
}
|
|
catch (err) {
|
|
if (err.status === 403) {
|
|
throw new error_1.FirebaseError(`You are not the owner of extension '${clc.bold(extensionRef)}' and don’t have the correct permissions to delete this extension.`, { status: err.status });
|
|
}
|
|
else if (err.status === 404) {
|
|
throw new error_1.FirebaseError(`Extension ${clc.bold(extensionRef)} was not found.`);
|
|
}
|
|
else if (err instanceof error_1.FirebaseError) {
|
|
throw err;
|
|
}
|
|
throw new error_1.FirebaseError(`Error occurred delete extension '${extensionRef}': ${err}`, {
|
|
status: err.status,
|
|
});
|
|
}
|
|
}
|
|
exports.deleteExtension = deleteExtension;
|
|
async function getExtension(extensionRef) {
|
|
const ref = refs.parse(extensionRef);
|
|
try {
|
|
const res = await apiClient.get(`/${refs.toExtensionName(ref)}`);
|
|
return res.body;
|
|
}
|
|
catch (err) {
|
|
if (err.status === 404) {
|
|
throw refNotFoundError(ref);
|
|
}
|
|
else if (err instanceof error_1.FirebaseError) {
|
|
throw err;
|
|
}
|
|
throw new error_1.FirebaseError(`Failed to query the extension '${clc.bold(extensionRef)}': ${err}`, {
|
|
status: err.status,
|
|
});
|
|
}
|
|
}
|
|
exports.getExtension = getExtension;
|
|
function refNotFoundError(ref) {
|
|
return new error_1.FirebaseError(`The extension reference '${clc.bold(ref.version ? refs.toExtensionVersionRef(ref) : refs.toExtensionRef(ref))}' doesn't exist. This could happen for two reasons:\n` +
|
|
` -The publisher ID '${clc.bold(ref.publisherId)}' doesn't exist or could be misspelled\n` +
|
|
` -The name of the ${ref.version ? "extension version" : "extension"} '${clc.bold(ref.version ? `${ref.extensionId}@${ref.version}` : ref.extensionId)}' doesn't exist or could be misspelled\n\n` +
|
|
`Please correct the extension reference and try again. If you meant to install an extension from a local source, please provide a relative path prefixed with '${clc.bold("./")}', '${clc.bold("../")}', or '${clc.bold("~/")}'. Learn more about local extension installation at ${marked("[https://firebase.google.com/docs/extensions/alpha/install-extensions_community#install](https://firebase.google.com/docs/extensions/alpha/install-extensions_community#install).")}`, { status: 404 });
|
|
}
|