@occam-scaly/scaly-cli 0.1.0

package/lib/scaly-api.js

@@ -0,0 +1,331 @@
+'use strict';
+
+const axios = require('axios');
+
+const STAGE_ENDPOINTS = {
+  prod: 'https://api.scaly.cloud/graphql',
+  dev: 'https://api-dev.scaly.cloud/graphql',
+  staging: 'https://api-staging.scaly.cloud/graphql'
+};
+
+function resolveApiEndpoint() {
+  return (
+    process.env.SCALY_API_URL ||
+    process.env.API_ENDPOINT ||
+    STAGE_ENDPOINTS[process.env.SCALY_STAGE || 'prod'] ||
+    STAGE_ENDPOINTS.prod
+  );
+}
+
+function resolveAuth() {
+  const bearer =
+    process.env.SCALY_API_BEARER ||
+    process.env.API_BEARER_TOKEN ||
+    process.env.API_BEARER;
+  if (bearer) {
+    return { mode: 'bearer', token: bearer };
+  }
+
+  const scalyApiKey = process.env.SCALY_API_KEY;
+  const appSyncApiKey = process.env.SCALY_APPSYNC_KEY;
+  if (scalyApiKey && appSyncApiKey) {
+    return { mode: 'keys', scalyApiKey, appSyncApiKey };
+  }
+
+  return null;
+}
+
+function buildHeaders(auth) {
+  if (!auth) return {};
+  if (auth.mode === 'bearer') {
+    return { authorization: `Bearer ${auth.token}` };
+  }
+  return {
+    'x-api-key': auth.appSyncApiKey,
+    'x-scaly-api-key': auth.scalyApiKey
+  };
+}
+
+async function graphqlRequest(query, variables) {
+  const endpoint = resolveApiEndpoint();
+  const auth = resolveAuth();
+  if (!auth) {
+    const e = new Error(
+      'Missing auth. Provide SCALY_API_BEARER (or run `scaly login`) OR set SCALY_API_KEY + SCALY_APPSYNC_KEY.'
+    );
+    e.code = 'SCALY_AUTH_MISSING';
+    throw e;
+  }
+  const res = await axios.post(
+    endpoint,
+    { query, variables },
+    {
+      headers: {
+        'content-type': 'application/json',
+        ...buildHeaders(auth)
+      },
+      timeout: 60_000
+    }
+  );
+  if (res.data?.errors?.length) {
+    const message =
+      res.data.errors?.[0]?.message || JSON.stringify(res.data.errors);
+    const e = new Error(`Scaly API error: ${message}`);
+    e.code = 'SCALY_API_ERROR';
+    e.details = res.data.errors;
+    throw e;
+  }
+  return res.data?.data;
+}
+
+const QUERIES = {
+  listAccountsBySlug: `
+    query ListAccountsBySlug($slug: String!) {
+      listAccounts(
+        where: {
+          AND: [
+            { slug: { equals: $slug } }
+            { isDeleted: { equals: false } }
+          ]
+        }
+        take: 5
+      ) {
+        id
+        name
+        slug
+        region
+      }
+    }
+  `,
+  listStacksByName: `
+    query ListStacksByName($name: String!) {
+      listStacks(
+        where: {
+          AND: [
+            { name: { equals: $name } }
+            { isDeleted: { equals: false } }
+          ]
+        }
+        take: 5
+      ) {
+        id
+        name
+        accountId
+        size
+        minIdle
+        status
+      }
+    }
+  `,
+  listAppsByName: `
+    query ListAppsByName($name: String!) {
+      listApps(
+        where: {
+          AND: [
+            { name: { equals: $name } }
+            { isDeleted: { equals: false } }
+          ]
+        }
+        take: 5
+      ) {
+        id
+        name
+        accountId
+        stackId
+        status
+        minIdle
+      }
+    }
+  `,
+  listAddOnsByName: `
+    query ListAddOnsByName($name: String!) {
+      listAddOns(
+        where: {
+          AND: [
+            { name: { equals: $name } }
+            { isDeleted: { equals: false } }
+          ]
+        }
+        take: 5
+      ) {
+        id
+        name
+        type
+        accountId
+        status
+        addOnDatabase { size type }
+        addOnCognito { userPoolName userPoolId }
+        addOnStorageS3 { bucket }
+      }
+    }
+  `,
+  listStacks: `
+    query ListStacks($take: Int) {
+      listStacks(
+        where: { isDeleted: { equals: false } }
+        take: $take
+      ) {
+        id
+        name
+        accountId
+        size
+        minIdle
+        status
+      }
+    }
+  `,
+  listApps: `
+    query ListApps($take: Int) {
+      listApps(
+        where: { isDeleted: { equals: false } }
+        take: $take
+      ) {
+        id
+        name
+        accountId
+        stackId
+        status
+        minIdle
+      }
+    }
+  `
+};
+
+const MUTATIONS = {
+  createStack: `
+    mutation CreateStack($data: StackCreateInput!) {
+      createStack(data: $data) { id name accountId size minIdle status }
+    }
+  `,
+  updateStack: `
+    mutation UpdateStack($where: StackWhereUniqueInput!, $data: StackUpdateInput) {
+      updateStack(where: $where, data: $data) { id name accountId size minIdle status }
+    }
+  `,
+  createApp: `
+    mutation CreateApp($data: AppCreateInput!) {
+      createApp(data: $data) { id name accountId stackId status minIdle }
+    }
+  `,
+  updateApp: `
+    mutation UpdateApp($where: AppWhereUniqueInput!, $data: AppUpdateInput) {
+      updateApp(where: $where, data: $data) { id name accountId stackId status minIdle }
+    }
+  `,
+  createAddOn: `
+    mutation CreateAddOn($data: AddOnCreateInput!) {
+      createAddOn(data: $data) { id name type accountId status }
+    }
+  `
+};
+
+async function findStackByName(name) {
+  const data = await graphqlRequest(QUERIES.listStacksByName, { name });
+  return data?.listStacks || [];
+}
+
+async function findAppByName(name) {
+  const data = await graphqlRequest(QUERIES.listAppsByName, { name });
+  return data?.listApps || [];
+}
+
+async function listStacks({ take = 50 } = {}) {
+  const data = await graphqlRequest(QUERIES.listStacks, { take });
+  return data?.listStacks || [];
+}
+
+async function listApps({ take = 100 } = {}) {
+  const data = await graphqlRequest(QUERIES.listApps, { take });
+  return data?.listApps || [];
+}
+
+async function findAccountBySlug(slug) {
+  try {
+    const data = await graphqlRequest(QUERIES.listAccountsBySlug, { slug });
+    return data?.listAccounts?.[0] || null;
+  } catch {
+    return null;
+  }
+}
+
+async function findAddOnByName(name) {
+  const data = await graphqlRequest(QUERIES.listAddOnsByName, { name });
+  return data?.listAddOns || [];
+}
+
+async function createStack({ accountId, name, size, minIdle }) {
+  const data = await graphqlRequest(MUTATIONS.createStack, {
+    data: {
+      name,
+      size,
+      minIdle: typeof minIdle === 'number' ? minIdle : undefined,
+      account: { connect: { id: accountId } }
+    }
+  });
+  return data?.createStack;
+}
+
+async function updateStack({ id, name, size, minIdle }) {
+  const data = await graphqlRequest(MUTATIONS.updateStack, {
+    where: { id },
+    data: {
+      name: name || undefined,
+      size: size || undefined,
+      minIdle: typeof minIdle === 'number' ? minIdle : undefined
+    }
+  });
+  return data?.updateStack;
+}
+
+async function createApp({ accountId, stackId, name, minIdle }) {
+  const data = await graphqlRequest(MUTATIONS.createApp, {
+    data: {
+      name,
+      minIdle: typeof minIdle === 'number' ? minIdle : undefined,
+      account: { connect: { id: accountId } },
+      stack: stackId ? { connect: { id: stackId } } : undefined
+    }
+  });
+  return data?.createApp;
+}
+
+async function updateApp({ id, stackId, name, minIdle }) {
+  const data = await graphqlRequest(MUTATIONS.updateApp, {
+    where: { id },
+    data: {
+      name: name || undefined,
+      minIdle: typeof minIdle === 'number' ? minIdle : undefined,
+      stack: stackId ? { connect: { id: stackId } } : undefined
+    }
+  });
+  return data?.updateApp;
+}
+
+async function createAddOn({ accountId, name, type, database }) {
+  const data = await graphqlRequest(MUTATIONS.createAddOn, {
+    data: {
+      name,
+      type,
+      account: { connect: { id: accountId } },
+      addOnDatabase: database ? { create: database } : undefined
+    }
+  });
+  return data?.createAddOn;
+}
+
+module.exports = {
+  resolveApiEndpoint,
+  resolveAuth,
+  graphqlRequest,
+  findAccountBySlug,
+  findStackByName,
+  findAppByName,
+  findAddOnByName,
+  listStacks,
+  listApps,
+  createStack,
+  updateStack,
+  createApp,
+  updateApp,
+  createAddOn
+};

package/lib/scaly-apply.js

@@ -0,0 +1,85 @@
+'use strict';
+
+const api = require('./scaly-api');
+
+async function applyPlan({ config, plan, autoApprove = false }) {
+  const actionable = (plan.operations || []).filter(
+    (o) => o.action === 'create' || o.action === 'update'
+  );
+
+  const results = [];
+
+  let createdStack = null;
+  let stackId = null;
+  const stackOp = (plan.operations || []).find((o) => o.kind === 'stack');
+  if (stackOp?.current?.id) stackId = stackOp.current.id;
+
+  for (const op of actionable) {
+    if (op.kind === 'stack' && op.action === 'create') {
+      const res = await api.createStack({
+        accountId: op.desired.accountId,
+        name: op.desired.name,
+        size: op.desired.size,
+        minIdle: op.desired.minIdle
+      });
+      createdStack = res;
+      stackId = res?.id || stackId;
+      results.push({ op_id: op.id, ok: true, result: res });
+      continue;
+    }
+
+    if (op.kind === 'stack' && op.action === 'update') {
+      const res = await api.updateStack({
+        id: op.resource.id,
+        name: op.desired.name,
+        size: op.desired.size,
+        minIdle: op.desired.minIdle
+      });
+      stackId = res?.id || stackId;
+      results.push({ op_id: op.id, ok: true, result: res });
+      continue;
+    }
+
+    if (op.kind === 'app' && op.action === 'create') {
+      if (!stackId) {
+        const stacks = await api.findStackByName(config.stack.name);
+        stackId = stacks?.[0]?.id || null;
+      }
+      const res = await api.createApp({
+        accountId: op.desired.accountId,
+        stackId,
+        name: op.desired.name
+      });
+      results.push({ op_id: op.id, ok: true, result: res });
+      continue;
+    }
+
+    if (op.kind === 'addon' && op.action === 'create') {
+      const res = await api.createAddOn({
+        accountId: op.desired.accountId,
+        name: op.desired.name,
+        type: op.desired.type,
+        database: op.desired.database || undefined
+      });
+      results.push({ op_id: op.id, ok: true, result: res });
+      continue;
+    }
+
+    results.push({
+      op_id: op.id,
+      ok: false,
+      error: { message: `Unsupported operation: ${op.kind}:${op.action}` }
+    });
+  }
+
+  const ok = results.every((r) => r.ok);
+  return {
+    ok,
+    auto_approve: !!autoApprove,
+    applied: actionable.length,
+    results,
+    created_stack_id: createdStack?.id || null
+  };
+}
+
+module.exports = { applyPlan };