relight-cli 0.2.0 → 0.3.0

package/src/lib/clouds/gcp.js

@@ -59,7 +59,7 @@ export async function mintAccessToken(clientEmail, privateKey) {
   var res = await fetch(TOKEN_URI, {
     method: "POST",
     headers: { "Content-Type": "application/x-www-form-urlencoded" },
-    body: `grant_type=${encodeURIComponent("urn:ietf:params:oauth:grant_type:jwt-bearer")}&assertion=${encodeURIComponent(jwt)}`,
+    body: `grant_type=${encodeURIComponent("urn:ietf:params:oauth:grant-type:jwt-bearer")}&assertion=${encodeURIComponent(jwt)}`,
   });
 
   if (!res.ok) {
@@ -302,6 +302,26 @@ export async function updateSqlUser(token, project, instanceName, userName, pass
   return waitForSqlOperation(token, project, op.name);
 }
 
+export async function deleteSqlUser(token, project, instanceName, userName) {
+  var op = await gcpApi(
+    "DELETE",
+    `${SQLADMIN_API}/projects/${project}/instances/${instanceName}/users?name=${encodeURIComponent(userName)}`,
+    null,
+    token
+  );
+  return waitForSqlOperation(token, project, op.name);
+}
+
+export async function listSqlDatabases(token, project, instanceName) {
+  var res = await gcpApi(
+    "GET",
+    `${SQLADMIN_API}/projects/${project}/instances/${instanceName}/databases`,
+    null,
+    token
+  );
+  return res.items || [];
+}
+
 // --- Cloud DNS ---
 
 export async function listManagedZones(token, project) {

package/src/lib/clouds/neon.js

@@ -0,0 +1,147 @@
+var API_BASE = "https://console.neon.tech/api/v2";
+
+export async function neonApi(apiKey, method, path, body) {
+  var headers = {
+    Authorization: `Bearer ${apiKey}`,
+    Accept: "application/json",
+  };
+
+  if (body && typeof body === "object") {
+    headers["Content-Type"] = "application/json";
+    body = JSON.stringify(body);
+  }
+
+  var res = await fetch(`${API_BASE}${path}`, {
+    method,
+    headers,
+    body: method === "GET" || method === "DELETE" ? undefined : body,
+  });
+
+  if (!res.ok) {
+    var text = await res.text();
+    throw new Error(`Neon API ${method} ${path}: ${res.status} ${text}`);
+  }
+
+  if (res.status === 204) return null;
+  return res.json();
+}
+
+// --- Projects ---
+
+export async function listProjects(apiKey) {
+  var data = await neonApi(apiKey, "GET", "/projects");
+  return data.projects || [];
+}
+
+export async function createProject(apiKey, opts = {}) {
+  var body = {
+    project: {
+      name: opts.name || "relight",
+      pg_version: opts.pgVersion || 16,
+    },
+  };
+  if (opts.regionId) body.project.region_id = opts.regionId;
+  return neonApi(apiKey, "POST", "/projects", body);
+}
+
+export async function getProject(apiKey, projectId) {
+  return neonApi(apiKey, "GET", `/projects/${projectId}`);
+}
+
+export async function deleteProject(apiKey, projectId) {
+  return neonApi(apiKey, "DELETE", `/projects/${projectId}`);
+}
+
+// --- Branches ---
+
+export async function listBranches(apiKey, projectId) {
+  var data = await neonApi(apiKey, "GET", `/projects/${projectId}/branches`);
+  return data.branches || [];
+}
+
+// --- Databases ---
+
+export async function listDatabases(apiKey, projectId, branchId) {
+  var data = await neonApi(
+    apiKey,
+    "GET",
+    `/projects/${projectId}/branches/${branchId}/databases`
+  );
+  return data.databases || [];
+}
+
+export async function createDatabase(apiKey, projectId, branchId, dbName, ownerName) {
+  return neonApi(
+    apiKey,
+    "POST",
+    `/projects/${projectId}/branches/${branchId}/databases`,
+    { database: { name: dbName, owner_name: ownerName } }
+  );
+}
+
+export async function deleteDatabase(apiKey, projectId, branchId, dbName) {
+  return neonApi(
+    apiKey,
+    "DELETE",
+    `/projects/${projectId}/branches/${branchId}/databases/${dbName}`
+  );
+}
+
+// --- Roles ---
+
+export async function createRole(apiKey, projectId, branchId, roleName) {
+  return neonApi(
+    apiKey,
+    "POST",
+    `/projects/${projectId}/branches/${branchId}/roles`,
+    { role: { name: roleName } }
+  );
+}
+
+export async function deleteRole(apiKey, projectId, branchId, roleName) {
+  return neonApi(
+    apiKey,
+    "DELETE",
+    `/projects/${projectId}/branches/${branchId}/roles/${roleName}`
+  );
+}
+
+export async function getRolePassword(apiKey, projectId, branchId, roleName) {
+  var data = await neonApi(
+    apiKey,
+    "GET",
+    `/projects/${projectId}/branches/${branchId}/roles/${roleName}/reveal_password`
+  );
+  return data.password;
+}
+
+export async function resetRolePassword(apiKey, projectId, branchId, roleName) {
+  var data = await neonApi(
+    apiKey,
+    "POST",
+    `/projects/${projectId}/branches/${branchId}/roles/${roleName}/reset_password`
+  );
+  return data.password;
+}
+
+// --- Connection URI ---
+
+export async function getConnectionUri(apiKey, projectId, dbName, roleName) {
+  var params = new URLSearchParams({
+    database_name: dbName,
+    role_name: roleName,
+  });
+  var data = await neonApi(
+    apiKey,
+    "GET",
+    `/projects/${projectId}/connection_uri?${params}`
+  );
+  return data.uri;
+}
+
+// --- Verification ---
+
+export async function verifyApiKey(apiKey) {
+  var projects = await listProjects(apiKey);
+  return projects;
+}

package/src/lib/config.js

@@ -11,23 +11,55 @@ export var CLOUD_NAMES = {
   cf: "Cloudflare",
   gcp: "GCP",
   aws: "AWS",
-  slicervm: "SlicerVM",
 };
 
 export var CLOUD_IDS = Object.keys(CLOUD_NAMES);
 
+export var SERVICE_TYPES = {
+  slicervm: { layer: "compute", name: "SlicerVM" },
+  neon: { layer: "db", name: "Neon" },
+};
+
 export function getConfig() {
   if (!existsSync(CONFIG_PATH)) {
     console.error("Not authenticated. Run `relight auth` first.");
     process.exit(1);
   }
-  return JSON.parse(readFileSync(CONFIG_PATH, "utf-8"));
+  var config = JSON.parse(readFileSync(CONFIG_PATH, "utf-8"));
+  return migrateSlicervm(config);
+}
+
+function migrateSlicervm(config) {
+  if (config.clouds && config.clouds.slicervm) {
+    if (!config.services) config.services = {};
+    if (!config.services.slicervm) {
+      var old = config.clouds.slicervm;
+      config.services.slicervm = {
+        layer: "compute",
+        type: "slicervm",
+        ...old,
+      };
+    }
+    delete config.clouds.slicervm;
+    if (config.default_cloud === "slicervm") {
+      delete config.default_cloud;
+    }
+    saveConfig(config);
+  }
+  // Migrate old "addons" key to "services"
+  if (config.addons && !config.services) {
+    config.services = config.addons;
+    delete config.addons;
+    saveConfig(config);
+  }
+  return config;
 }
 
 export function tryGetConfig() {
   if (!existsSync(CONFIG_PATH)) return null;
   try {
-    return JSON.parse(readFileSync(CONFIG_PATH, "utf-8"));
+    var config = JSON.parse(readFileSync(CONFIG_PATH, "utf-8"));
+    return migrateSlicervm(config);
   } catch {
     return null;
   }
@@ -84,15 +116,141 @@ export function resolveCloudConfig(cloudId) {
   if (cloudId === "aws") {
     return { accessKeyId: cloud.accessKeyId, secretAccessKey: cloud.secretAccessKey, region: cloud.region };
   }
-  if (cloudId === "slicervm") {
-    var slicerCfg = { hostGroup: cloud.hostGroup, baseDomain: cloud.baseDomain };
-    if (cloud.socketPath) {
-      slicerCfg.socketPath = cloud.socketPath;
+  return cloud;
+}
+
+export function getServiceConfig(name) {
+  var config = getConfig();
+  var service = config.services && config.services[name];
+  if (!service) {
+    console.error(
+      `Service '${name}' not found. Run \`relight service add\` to register it.`
+    );
+    process.exit(1);
+  }
+  return service;
+}
+
+export function tryGetServiceConfig(name) {
+  var config = tryGetConfig();
+  if (!config || !config.services) return null;
+  return config.services[name] || null;
+}
+
+export function getRegisteredServices() {
+  var config = tryGetConfig();
+  if (!config || !config.services) return [];
+  return Object.entries(config.services).map(([name, service]) => ({
+    name,
+    ...service,
+  }));
+}
+
+export function saveServiceConfig(name, data) {
+  var config = tryGetConfig() || { clouds: {} };
+  if (!config.services) config.services = {};
+  config.services[name] = data;
+  saveConfig(config);
+}
+
+export function removeServiceConfig(name) {
+  var config = tryGetConfig();
+  if (!config || !config.services) return;
+  delete config.services[name];
+  saveConfig(config);
+}
+
+export function getCloudMeta(cloudId, key) {
+  var config = tryGetConfig();
+  if (!config || !config.clouds || !config.clouds[cloudId]) return undefined;
+  var meta = config.clouds[cloudId]._meta;
+  if (!meta) return undefined;
+  return key ? meta[key] : meta;
+}
+
+export function setCloudMeta(cloudId, key, value) {
+  var config = getConfig();
+  if (!config.clouds[cloudId]._meta) config.clouds[cloudId]._meta = {};
+  if (value === undefined) {
+    delete config.clouds[cloudId]._meta[key];
+    if (Object.keys(config.clouds[cloudId]._meta).length === 0) {
+      delete config.clouds[cloudId]._meta;
+    }
+  } else {
+    config.clouds[cloudId]._meta[key] = value;
+  }
+  saveConfig(config);
+}
+
+export function getServiceMeta(serviceName, key) {
+  var config = tryGetConfig();
+  if (!config || !config.services || !config.services[serviceName]) return undefined;
+  var meta = config.services[serviceName]._meta;
+  if (!meta) return undefined;
+  return key ? meta[key] : meta;
+}
+
+export function setServiceMeta(serviceName, key, value) {
+  var config = getConfig();
+  if (!config.services || !config.services[serviceName]) {
+    throw new Error(`Service '${serviceName}' not found.`);
+  }
+  if (!config.services[serviceName]._meta) config.services[serviceName]._meta = {};
+  if (value === undefined) {
+    delete config.services[serviceName]._meta[key];
+    if (Object.keys(config.services[serviceName]._meta).length === 0) {
+      delete config.services[serviceName]._meta;
+    }
+  } else {
+    config.services[serviceName]._meta[key] = value;
+  }
+  saveConfig(config);
+}
+
+// --- Database registry ---
+
+export function getDatabaseConfig(name) {
+  var config = tryGetConfig();
+  if (!config || !config.databases) return null;
+  return config.databases[name] || null;
+}
+
+export function saveDatabaseConfig(name, data) {
+  var config = tryGetConfig() || { clouds: {} };
+  if (!config.databases) config.databases = {};
+  config.databases[name] = data;
+  saveConfig(config);
+}
+
+export function removeDatabaseConfig(name) {
+  var config = tryGetConfig();
+  if (!config || !config.databases) return;
+  delete config.databases[name];
+  saveConfig(config);
+}
+
+export function listDatabases() {
+  var config = tryGetConfig();
+  if (!config || !config.databases) return [];
+  return Object.entries(config.databases).map(([name, data]) => ({
+    name,
+    ...data,
+  }));
+}
+
+export function normalizeServiceConfig(service) {
+  if (service.type === "slicervm") {
+    var cfg = { hostGroup: service.hostGroup, baseDomain: service.baseDomain };
+    if (service.socketPath) {
+      cfg.socketPath = service.socketPath;
     } else {
-      slicerCfg.apiUrl = cloud.apiUrl;
-      slicerCfg.apiToken = cloud.token;
+      cfg.apiUrl = service.apiUrl;
+      cfg.apiToken = service.token;
     }
-    return slicerCfg;
+    return cfg;
   }
-  return cloud;
+  if (service.type === "neon") {
+    return { apiKey: service.apiKey };
+  }
+  return service;
 }

package/src/lib/link.js

@@ -14,8 +14,14 @@ export function readLink() {
   }
 }
 
-export function linkApp(name, cloud, dns, db) {
-  var data = { app: name, cloud };
+export function linkApp(name, cloud, dns, db, compute) {
+  var data = { app: name };
+  if (compute) {
+    data.compute = compute;
+  }
+  if (cloud) {
+    data.cloud = cloud;
+  }
   if (dns && dns !== cloud) data.dns = dns;
   if (db && db !== cloud) data.db = db;
   writeFileSync(LINK_FILE, YAML.stringify(data));
@@ -53,3 +59,8 @@ export function resolveDb() {
   var linked = readLink();
   return linked?.db || null;
 }
+
+export function resolveCompute() {
+  var linked = readLink();
+  return linked?.compute || null;
+}