great 0.0.4 → 0.3.2

package/dist/whoami/index.js

@@ -0,0 +1,21 @@
+import chalk from 'chalk';
+import callApi from '../utils/callApi.js';
+export const action = (log, apiToken) => async function whoami() {
+    const response = await callApi('https://api.integreat.io/whoami', apiToken);
+    if (response.error) {
+        log(chalk.red(response.error));
+        return;
+    }
+    const username = response.user?.id;
+    if (username) {
+        log(chalk.white(username));
+    }
+    else {
+        log(chalk.red('You are not logged in to Integreat.'));
+    }
+};
+export default (program, apiToken) => program
+    .command('whoami')
+    .description('display your Integreat user name')
+    .action(action(console.log, apiToken));
+//# sourceMappingURL=index.js.map

package/dist/whoami/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/whoami/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAA;AACzB,OAAO,OAA0B,MAAM,qBAAqB,CAAA;AAO5D,MAAM,CAAC,MAAM,MAAM,GAAG,CAAC,GAA8B,EAAE,QAAiB,EAAE,EAAE,CAC1E,KAAK,UAAU,MAAM;IACnB,MAAM,QAAQ,GAAG,MAAM,OAAO,CAC5B,iCAAiC,EACjC,QAAQ,CACT,CAAA;IACD,IAAI,QAAQ,CAAC,KAAK,EAAE,CAAC;QACnB,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAA;QAC9B,OAAM;IACR,CAAC;IAED,MAAM,QAAQ,GAAG,QAAQ,CAAC,IAAI,EAAE,EAAE,CAAA;IAClC,IAAI,QAAQ,EAAE,CAAC;QACb,GAAG,CAAC,KAAK,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC,CAAA;IAC5B,CAAC;SAAM,CAAC;QACN,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC,qCAAqC,CAAC,CAAC,CAAA;IACvD,CAAC;AACH,CAAC,CAAA;AAEH,eAAe,CAAC,OAAgB,EAAE,QAAiB,EAAE,EAAE,CACrD,OAAO;KACJ,OAAO,CAAC,QAAQ,CAAC;KACjB,WAAW,CAAC,kCAAkC,CAAC;KAC/C,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,GAAG,EAAE,QAAQ,CAAC,CAAC,CAAA"}

package/eslint.config.js

@@ -0,0 +1,27 @@
+import pluginPromise from 'eslint-plugin-promise'
+import pluginSecurity from 'eslint-plugin-security'
+import eslintConfigPrettier from 'eslint-config-prettier'
+
+import eslint from '@eslint/js'
+import tseslint from 'typescript-eslint'
+
+export default tseslint.config(
+  eslint.configs.recommended,
+  tseslint.configs.strict,
+  tseslint.configs.stylistic,
+  eslintConfigPrettier,
+  pluginPromise.configs['flat/recommended'],
+  pluginSecurity.configs.recommended,
+  {
+    rules: {
+      'no-unused-vars': 0,
+      '@typescript-eslint/no-unused-vars': [
+        'error',
+        { argsIgnorePattern: '^_', ignoreRestSiblings: true },
+      ],
+    },
+    linterOptions: {
+      reportUnusedDisableDirectives: 'error',
+    },
+  },
+)

package/package.json

@@ -1,17 +1,52 @@
 {
   "name": "great",
-  "version": "0.0.4",
-  "description": "Another task runner with js",
-  "main": "index.js",
+  "version": "0.3.2",
+  "description": "A CLI for Integreat",
+  "author": "Kjell-Morten Bratsberg Thorsen <kjellmorten@integreat.io>",
+  "license": "UNLICENSED",
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "bin": {
+    "great": "dist/index.js"
+  },
+  "scripts": {
+    "test": "node --import tsx --no-deprecation --test --enable-source-maps --experimental-test-coverage --test-reporter node-test-reporter \"src/**/*.test.ts\"",
+    "test:watch": "npm run dev",
+    "dev": "node --import tsx --no-deprecation --test --enable-source-maps --test-reporter node-test-reporter --watch \"src/**/*.test.ts\" || exit 0",
+    "build": "tsc",
+    "prepublishOnly": "npm run build",
+    "coverage": "c8 report",
+    "lint": "eslint --ext .ts src",
+    "typecheck": "tsc --noEmit --strict",
+    "verify": "npm run lint && npm run typecheck && npm test"
+  },
   "repository": {
     "type": "git",
-    "url": "git@github.com:fritx/great.git"
+    "url": "git+https://github.com/integreat-io/great.git"
+  },
+  "bugs": {
+    "url": "https://github.com/integreat-io/great/issues"
+  },
+  "homepage": "https://github.com/integreat-io/great#readme",
+  "dependencies": {
+    "@inquirer/prompts": "^7.4.0",
+    "chalk": "^5.4.1",
+    "columnify": "^1.6.0",
+    "commander": "^13.1.0",
+    "ky": "^1.7.5",
+    "ora": "^8.2.0"
   },
-  "keywords": [
-    "task",
-    "runner",
-    "build",
-    "flow"
-  ],
-  "license": "MIT"
+  "devDependencies": {
+    "@integreat/ts-dev-setup": "^8.1.2",
+    "@types/columnify": "^1.5.4",
+    "@types/node": "^22.13.10",
+    "@types/sinon": "^17.0.4",
+    "integreat": "^1.6.1",
+    "sinon": "^19.0.2"
+  }
 }

package/src/accounts/index.ts

@@ -0,0 +1,41 @@
+import chalk from 'chalk'
+import columnify from 'columnify'
+import callApi, { type Response } from '../utils/callApi.js'
+import type { Command } from 'commander'
+
+interface AccountsResponse extends Response {
+  accounts?: [{ id: string; name: string }]
+}
+
+export const action = (log: (message: string) => void, apiToken?: string) =>
+  async function accountsList() {
+    const response = await callApi<AccountsResponse>(
+      'https://api.integreat.io/accounts',
+      apiToken,
+    )
+    if (response.error) {
+      log(chalk.red(response.error))
+      return
+    }
+
+    const accounts = response.accounts
+    if (Array.isArray(accounts) && accounts.length > 0) {
+      log(columnify(accounts, { columns: ['id', 'name'] }))
+    } else {
+      log(chalk.white('No accounts.'))
+    }
+  }
+
+export default (program: Command, apiToken?: string) => {
+  const projects = program
+    .command('accounts')
+    .description(
+      'commands for accounts, run `great accounts --help` to see options. `great accounts` is also a shortcut for `great accounts list`',
+    )
+    .action(action(console.log, apiToken))
+
+  projects
+    .command('list')
+    .description('list all accounts you have access to')
+    .action(action(console.log, apiToken))
+}

package/src/index.ts

@@ -0,0 +1,22 @@
+#!/usr/bin/env node
+
+import { program } from 'commander'
+import accounts from './accounts/index.js'
+import now from './now/index.js'
+import projects from './projects/index.js'
+import pull from './pull/index.js'
+import run from './run/index.js'
+import whoami from './whoami/index.js'
+
+const apiToken = process.env.GREAT_TOKEN
+
+program.version('0.3.2', '-v, --version').description('Integreat CLI')
+
+accounts(program, apiToken)
+now(program)
+projects(program, apiToken)
+pull(program, apiToken)
+run(program, apiToken)
+whoami(program, apiToken)
+
+program.parse(process.argv)

package/src/now/index.test.ts

@@ -0,0 +1,31 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import sinon from 'sinon'
+
+import { action } from './index.js'
+
+// Tests
+
+test('should return timestamp', () => {
+  const log = sinon.stub()
+
+  const before = Date.now()
+  action(log)()
+  const after = Date.now()
+
+  assert.equal(log.callCount, 1)
+  const message = log.args[0][0]
+  assert.equal(typeof message, 'string')
+  const ms = Number.parseInt(message.slice(5, 18)) // We extract the number within the formatting
+  assert.equal(typeof ms, 'number')
+  assert.equal(
+    ms >= before,
+    true,
+    'Milliseconds should be greater than or equal the before timestamp',
+  )
+  assert.equal(
+    ms <= after,
+    true,
+    'Milliseconds should be less than or equal the after timestamp',
+  )
+})

package/src/now/index.ts

@@ -0,0 +1,15 @@
+import chalk from 'chalk'
+import type { Command } from 'commander'
+
+export const action = (log: (message: string) => void) =>
+  function now() {
+    log(chalk.white(Date.now()))
+  }
+
+export default (program: Command) =>
+  program
+    .command('now')
+    .description(
+      'display current time as a Unix time stamp (milliseconds since 1970-01-01',
+    )
+    .action(action(console.log))

package/src/projects/describe.ts

@@ -0,0 +1,80 @@
+import chalk from 'chalk'
+import columnify from 'columnify'
+import callApi, { type Response } from '../utils/callApi.js'
+import type { Command } from 'commander'
+
+interface Project {
+  id: string
+  name: string
+  status: string
+  shared?: boolean
+  createdAt: string
+  updatedAt: string
+  values: Record<string, string>
+}
+
+interface ProjectResponse extends Response {
+  project?: Project
+}
+
+const prepareDetails = ({
+  id,
+  name,
+  status,
+  shared,
+  createdAt,
+  updatedAt,
+}: Project) => ({
+  id,
+  name,
+  status,
+  shared: shared ?? false,
+  createdAt,
+  updatedAt,
+})
+
+const prepareValues = (values: Record<string, string>) =>
+  Object.fromEntries(
+    Object.entries(values).map(([key, value]) =>
+      key.endsWith('$secret')
+        ? [key.slice(0, key.length - 7), `🔒 ${value}`]
+        : [key, value],
+    ),
+  )
+
+export const action = (log: (message: string) => void, apiToken?: string) =>
+  async function projectList(projectId?: string) {
+    const url = `https://api.integreat.io/projects/${projectId}`
+
+    const response = await callApi<ProjectResponse>(url, apiToken)
+    if (response.error) {
+      log(chalk.red(response.error))
+      return
+    }
+
+    const project = response.project
+    if (project) {
+      const details = prepareDetails(project)
+      log(columnify(details, { columns: ['key', 'value'] }))
+
+      if (project.values) {
+        log(chalk.yellow('\nValues:'))
+        const values = prepareValues(project.values)
+        log(columnify(values, { columns: ['key', 'value'] }))
+      } else {
+        log('\nNo values')
+      }
+    } else {
+      log(chalk.white('No project.'))
+    }
+  }
+
+export default (program: Command, apiToken?: string) =>
+  program
+    .command('describe')
+    .description('show project details')
+    .argument(
+      '[project]',
+      'id of the project. if not given, the id of the local project is used',
+    )
+    .action(action(console.log, apiToken))

package/src/projects/index.ts

@@ -0,0 +1,61 @@
+import chalk from 'chalk'
+import columnify from 'columnify'
+import callApi, { type Response } from '../utils/callApi.js'
+import describe from './describe.js'
+import type { Command } from 'commander'
+
+interface ProjectsResponse extends Response {
+  projects?: [{ id: string; name: string }]
+  meta?: {
+    totalCount: number
+  }
+}
+
+export const action = (log: (message: string) => void, apiToken?: string) =>
+  async function projectList(accountId?: string) {
+    const url = accountId
+      ? `https://api.integreat.io/accounts/${accountId}/projects?pageSize=50`
+      : 'https://api.integreat.io/projects?pageSize=50'
+
+    const response = await callApi<ProjectsResponse>(url, apiToken)
+    if (response.error) {
+      log(chalk.red(response.error))
+      return
+    }
+
+    const projects = response.projects
+    if (Array.isArray(projects) && projects.length > 0) {
+      log(columnify(projects, { columns: ['id', 'name'] }))
+
+      const count = response.meta?.totalCount
+      if (count) {
+        log(`\n${count} projects`)
+      }
+    } else {
+      log(chalk.white('No projects.'))
+    }
+  }
+
+export default (program: Command, apiToken?: string) => {
+  const projects = program
+    .command('projects')
+    .description(
+      'commands for projects, run `great projects --help` to see options. `great projects` is also a shortcut for `great projects list`',
+    )
+    .argument(
+      '[account]',
+      'id of an account to fetch projects for, or leave it out to fetch all projects',
+    )
+    .action(action(console.log, apiToken))
+
+  projects
+    .command('list')
+    .description('list all projects you have access to')
+    .argument(
+      '[account]',
+      'id of an account to fetch projects for, or leave it out to fetch all projects',
+    )
+    .action(action(console.log, apiToken))
+
+  describe(projects, apiToken)
+}

package/src/pull/index.ts

@@ -0,0 +1,45 @@
+import chalk from 'chalk'
+import callApi, { type Response } from '../utils/callApi.js'
+import saveProject from '../utils/saveProject.js'
+import { fetchIdFromIndex } from '../utils/fetchLocalProject.js'
+import type { Command } from 'commander'
+import type { Definitions } from 'integreat'
+
+interface ProjectResponse extends Response {
+  project?: { id: string; name: string; definitions?: Definitions }
+}
+
+export const action = (log: (message: string) => void, apiToken?: string) =>
+  async function pullProject(projectId?: string) {
+    const id = projectId ?? fetchIdFromIndex()
+    if (!id) {
+      log(chalk.red('No project argument and no local project'))
+      return
+    }
+
+    const url = `https://api.integreat.io/projects/${id}`
+
+    const response = await callApi<ProjectResponse>(url, apiToken)
+    if (response.error) {
+      log(chalk.red(response.error))
+      return
+    }
+
+    const defs = response.project?.definitions
+    if (defs) {
+      const root = projectId ? projectId : undefined // Use the projectId as root folder if provided as arg
+      saveProject(id, defs, root)
+    } else {
+      log(chalk.red('Project has no definitions'))
+    }
+  }
+
+export default (program: Command, apiToken?: string) =>
+  program
+    .command('pull')
+    .description('pull a project config to a folder structure')
+    .argument(
+      '[project]',
+      'id of the project to pull, will override any id in the local index file',
+    )
+    .action(action(console.log, apiToken))

package/src/run/index.ts

@@ -0,0 +1,81 @@
+import chalk from 'chalk'
+import ora from 'ora'
+import { setTimeout } from 'timers/promises'
+import { select } from '@inquirer/prompts'
+import callApi, { type Response } from '../utils/callApi.js'
+import { fetchIdFromIndex } from '../utils/fetchLocalProject.js'
+import type { Command } from 'commander'
+
+interface JobsResponse extends Response {
+  jobs?: [
+    {
+      id: string
+      name: string
+      description?: string
+      watch?: boolean
+      sort?: number
+      allowManualDispatch?: boolean
+    },
+  ]
+}
+
+export const action = (log: (message: string) => void, apiToken?: string) =>
+  async function projectList(projectId?: string) {
+    const id = projectId ?? fetchIdFromIndex()
+    if (!id) {
+      log(chalk.red('No project id given and none found in local project'))
+      return
+    }
+    const url = `https://api.integreat.io/projects/${id}/jobs`
+
+    const response = await callApi<JobsResponse>(url, apiToken)
+    if (response.error) {
+      log(chalk.red(response.error))
+      return
+    }
+
+    const jobs = response.jobs
+    if (Array.isArray(jobs) && jobs.length > 0) {
+      const hasWatchJobs = jobs.some((job) => job.watch)
+      const listJobs = (
+        hasWatchJobs ? jobs.filter((job) => job.watch) : jobs
+      ).sort((a, b) => (a.sort ?? 0) - (b.sort ?? 0))
+
+      let jobId
+      try {
+        jobId = await select({
+          message: 'Select a job to run',
+          choices: listJobs.map((job) => ({
+            name: job.name,
+            value: job.id,
+            description: job.description,
+          })),
+          pageSize: 20,
+          loop: false,
+        })
+      } catch (error) {
+        console.error('Job failed', error)
+      }
+
+      if (jobId) {
+        const spinner = ora().start()
+        await setTimeout(1000)
+        spinner.stop()
+        log('Job would have run if we had implemented the run command ...')
+      }
+    } else {
+      log(chalk.white('No jobs for this project.'))
+    }
+  }
+
+export default (program: Command, apiToken?: string) =>
+  program
+    .command('run')
+    .description(
+      'run a job in the current project or the project with the provided id',
+    )
+    .argument(
+      '[project]',
+      'id of the project to run jobs for, will override any id in the local index file',
+    )
+    .action(action(console.log, apiToken))

package/src/utils/callApi.ts

@@ -0,0 +1,29 @@
+import ky from 'ky'
+import ora from 'ora'
+
+export interface Response {
+  status?: string
+  error?: string
+}
+
+export default async function callApi<T extends Response>(
+  uri: string,
+  token?: string,
+): Promise<T> {
+  if (!token) {
+    return {
+      status: 'noaccess',
+      error: 'You are not logged in to Integreat.',
+    } as T
+  }
+
+  const spinner = ora().start()
+  const response = await ky
+    .get(uri, {
+      headers: { Authorization: `Bearer ${token}` },
+      throwHttpErrors: false,
+    })
+    .json<T>()
+  spinner.stop()
+  return response
+}

package/src/utils/fetchLocalProject.ts

@@ -0,0 +1,12 @@
+import fs from 'node:fs'
+
+export function fetchIdFromIndex() {
+  try {
+    const content = fs.readFileSync('index.json', 'utf8')
+    const index = JSON.parse(content)
+    return index.id
+  } catch {
+    // TODO: Do proper error handling
+    return undefined
+  }
+}

package/src/utils/saveProject.ts

@@ -0,0 +1,106 @@
+/* eslint-disable security/detect-non-literal-fs-filename */
+import fs from 'node:fs'
+import type { Definitions } from 'integreat'
+
+const normalizeFolderName = (folder: string) => folder.replace(':', '_')
+
+function createFolderIfMissing(root?: string) {
+  const rootPath = root ? `${root}/` : ''
+  return (name: string) => {
+    const path = `${rootPath}${name}`
+
+    if (!fs.existsSync(path)) {
+      fs.mkdirSync(path)
+    }
+  }
+}
+
+function writeJsonFile(root?: string) {
+  const rootPath = root ? `${root}/` : ''
+  return (folder: string | null, name: string, content: unknown) => {
+    const path = folder
+      ? `${rootPath}${folder}/${name}.json`
+      : `${rootPath}${name}.json`
+    fs.writeFileSync(path, JSON.stringify(content, undefined, 2))
+  }
+}
+
+export default function saveProject(
+  id: string,
+  defs: Definitions,
+  root?: string,
+) {
+  const {
+    identConfig,
+    nonvalues,
+    queueService,
+    flags,
+    schemas,
+    services,
+    mutations,
+    auths,
+    dictionaries,
+    jobs,
+  } = defs
+
+  const rootFolder = root ? normalizeFolderName(root) : undefined
+  const createFolder = createFolderIfMissing(rootFolder)
+  const writeFile = writeJsonFile(rootFolder)
+
+  // Set up root folder
+  if (rootFolder) {
+    createFolderIfMissing()(rootFolder)
+  }
+
+  // Index
+  const index = { id, flags, identConfig, nonvalues, queueService }
+  writeFile(null, 'index', index)
+
+  // Schemas
+  createFolder('schemas')
+  if (schemas) {
+    schemas.forEach((schema) => {
+      writeFile('schemas', schema.id, schema)
+    })
+  }
+
+  // Services
+  createFolder('services')
+  if (services) {
+    services.forEach((service) => {
+      writeFile('services', service.id, service)
+    })
+  }
+
+  // Mutations
+  createFolder('mutations')
+  if (mutations) {
+    Object.entries(mutations).forEach(([id, mutation]) => {
+      writeFile('mutations', id, { id, pipeline: mutation })
+    })
+  }
+
+  // Auths
+  createFolder('auths')
+  if (auths) {
+    auths.forEach((auth) => {
+      writeFile('auths', auth.id, auth)
+    })
+  }
+
+  // Dictionaries
+  createFolder('dictionaries')
+  if (dictionaries) {
+    Object.entries(dictionaries).forEach(([id, dictionary]) => {
+      writeFile('dictionaries', id, dictionary)
+    })
+  }
+
+  // Jobs
+  createFolder('jobs')
+  if (jobs) {
+    jobs.forEach((job, index) => {
+      writeFile('jobs', job.id ?? `job${index}`, job) // id is required in practice, but not in the typing ...
+    })
+  }
+}

package/src/whoami/index.ts

@@ -0,0 +1,32 @@
+import chalk from 'chalk'
+import callApi, { type Response } from '../utils/callApi.js'
+import type { Command } from 'commander'
+
+interface UserResponse extends Response {
+  user?: { id: string }
+}
+
+export const action = (log: (message: string) => void, apiToken?: string) =>
+  async function whoami() {
+    const response = await callApi<UserResponse>(
+      'https://api.integreat.io/whoami',
+      apiToken,
+    )
+    if (response.error) {
+      log(chalk.red(response.error))
+      return
+    }
+
+    const username = response.user?.id
+    if (username) {
+      log(chalk.white(username))
+    } else {
+      log(chalk.red('You are not logged in to Integreat.'))
+    }
+  }
+
+export default (program: Command, apiToken?: string) =>
+  program
+    .command('whoami')
+    .description('display your Integreat user name')
+    .action(action(console.log, apiToken))