ad4m-host
Version:
Self hosting ad4m service
129 lines (128 loc) • 5.31 kB
JavaScript
import { LanguageMetaInput } from '@perspect3vism/ad4m';
import { buildAd4mClient, prettify } from './util';
import ReadlineSync from 'readline-sync';
export const command = 'languages [action]';
export const desc = 'Languages related action';
export const builder = (yargs) => yargs
.positional('action', {
type: 'string',
describe: 'Action that should be executed on the languages',
choices: ['get', 'writeSettings', 'applyTemplateAndPublish', 'publish', 'meta', 'source'],
})
.options({
address: { type: "string", describe: 'Address of the language' },
filter: { type: "string", describe: 'Filter the languages when query' },
all: { type: "boolean", describe: 'Flag to request all the languages' },
settings: { type: "string", describe: 'Settings of the language to write' },
templateData: { type: "string", describe: 'Apply template data when publish templated language' },
path: { type: "string", describe: 'Refer to the language under this path' },
meta: { type: "string", describe: 'metadata of the language' }
});
export const handler = async (argv) => {
const { server, address, filter, all, settings, templateData, path, meta, action } = argv;
const ad4mClient = buildAd4mClient(server);
switch (action) {
case 'get':
await get(ad4mClient, address, filter, all);
break;
case 'writeSettings':
await writeSettings(ad4mClient, address, settings);
break;
case 'applyTemplateAndPublish':
await applyTemplateAndPublish(ad4mClient, address, templateData);
break;
case 'publish':
await publish(ad4mClient, path, meta);
break;
case 'meta':
await getMeta(ad4mClient, address);
break;
case 'source':
await source(ad4mClient, address);
break;
default:
console.info(`Action "${argv.action}" is not defined on languages.`);
break;
}
process.exit();
};
async function get(ad4mClient, address, filter, all) {
if (address) {
const language = await ad4mClient.languages.byAddress(address);
prettify(language);
return;
}
if (filter) {
const languages = await ad4mClient.languages.byFilter(filter);
prettify(languages);
return;
}
if (all) {
const languages = (await ad4mClient.languages.all()).map(l => {
return { name: l.name, address: l.address };
});
prettify(languages);
return;
}
console.info('Language get action is missing param <address>/<filter>/<all>');
}
async function writeSettings(ad4mClient, address, settings) {
if (address == undefined || settings == undefined) {
console.info('Language writeSettings action is missing params <address> and <settings>');
return;
}
const result = await ad4mClient.languages.writeSettings(address, settings);
prettify(result);
}
async function applyTemplateAndPublish(ad4mClient, address, templateData) {
if (address == undefined || templateData == undefined) {
console.info('Language applyTemplateAndPublish action is missing params <address> and <templateData>');
return;
}
const result = await ad4mClient.languages.applyTemplateAndPublish(address, templateData);
prettify(result);
}
async function publish(ad4mClient, path, meta) {
let languageMetaInput;
if (path == undefined) {
path = ReadlineSync.question("Path of the bundled file: ");
}
if (meta == undefined) {
const name = ReadlineSync.question("Name (must match name in source code): ");
const description = ReadlineSync.question("Description: ");
const templateParams = ReadlineSync.question("In case of a templateable Language, list of template parameters (comma separated): ");
const sourceLink = ReadlineSync.question("Link to source code / Github repo: ");
languageMetaInput = new LanguageMetaInput(name, description);
if (sourceLink.trim().length > 0) {
languageMetaInput.sourceCodeLink = sourceLink.trim();
}
const params = templateParams.split(',').map(e => e.trim());
if (params.length > 0) {
languageMetaInput.possibleTemplateParams = params;
}
}
else {
let languageMetaObj = JSON.parse(meta);
languageMetaInput = new LanguageMetaInput(languageMetaObj.name, languageMetaObj.description);
languageMetaInput.sourceCodeLink = languageMetaObj.sourceCodeLink.trim();
languageMetaInput.possibleTemplateParams = languageMetaObj.possibleTemplateParams;
}
const result = await ad4mClient.languages.publish(path, languageMetaInput);
prettify(result);
}
async function getMeta(ad4mClient, address) {
if (address) {
const result = await ad4mClient.languages.meta(address);
prettify(result);
return;
}
console.info('Language meta action is missing param <address>');
}
async function source(ad4mClient, address) {
if (address) {
const result = await ad4mClient.languages.source(address);
console.log(result);
return;
}
console.info('Language source action is missing param <address>');
}