Merge pull request #7 from sasjs/issue-6

Add deploy endpoint

.github/workflows/npmpublish.yml

@@ -19,3 +19,4 @@ jobs:
         uses: cycjimmy/semantic-release-action@v2
         env:
           GITHUB_TOKEN: ${{ secrets.GH_TOKEN }}
+          NPM_TOKEN: ${{ secrets.NPM_TOKEN }}

.gitignore

@@ -4,3 +4,4 @@ node_modules/
 .DS_Store
 .env*
 sas/
+tmp/

jest.config.js

@@ -0,0 +1,13 @@
+module.exports = {
+  preset: 'ts-jest',
+  testEnvironment: 'node',
+  coverageThreshold: {
+    global: {
+      branches: 80,
+      functions: 80,
+      lines: 80,
+      statements: -10
+    }
+  },
+  collectCoverageFrom: ['src/**/{!(index),}.ts']
+}

package.json

@@ -2,12 +2,13 @@
   "name": "server",
   "version": "0.0.1",
   "description": "SASjs server",
-  "main": "./src/index.ts",
+  "main": "./src/server.ts",
   "scripts": {
     "start": "nodemon ./src/index.ts",
     "build": "tsc --project ./",
     "semantic-release": "semantic-release -d",
-    "postinstall": "[ -d .git ] && git config core.hooksPath ./.git-hooks || true",
+    "prepare": "[ -d .git ] && git config core.hooksPath ./.git-hooks || true",
+    "test": "jest --coverage",
     "lint:fix": "npx prettier --write \"src/**/*.{ts,tsx,js,jsx,html,css,sass,less,yml,md,graphql}\"",
     "lint": "npx prettier --check \"src/**/*.{ts,tsx,js,jsx,html,css,sass,less,yml,md,graphql}\""
   },
@@ -18,16 +19,21 @@
   },
   "author": "Analytium Ltd",
   "dependencies": {
-    "@sasjs/utils": "^2.19.0",
+    "@sasjs/utils": "^2.23.3",
     "child_process": "^1.0.2",
     "express": "^4.17.1"
   },
   "devDependencies": {
     "@types/express": "^4.17.12",
+    "@types/jest": "^26.0.24",
     "@types/node": "^15.12.2",
+    "@types/supertest": "^2.0.11",
+    "jest": "^27.0.6",
     "nodemon": "^2.0.7",
     "prettier": "^2.3.1",
     "semantic-release": "^17.4.3",
+    "supertest": "^6.1.3",
+    "ts-jest": "^27.0.3",
     "ts-node": "^10.0.0",
     "typescript": "^4.3.2"
   }

src/app.ts

@@ -0,0 +1,10 @@
+import express from 'express'
+import indexRouter from './routes'
+
+const app = express()
+
+app.use(express.json())
+
+app.use('/', indexRouter)
+
+export default app

src/controllers/deploy.ts

@@ -0,0 +1,59 @@
+import { MemberType, FolderMember, ServiceMember } from '../types'
+import { getTmpFilesFolderPath } from '../utils/file'
+import { createFolder, createFile, asyncForEach } from '@sasjs/utils'
+import path from 'path'
+
+export const createFileTree = async (
+  members: [FolderMember, ServiceMember],
+  parentFolders: string[] = []
+) => {
+  const destinationPath = path.join(
+    getTmpFilesFolderPath(),
+    path.join(...parentFolders)
+  )
+
+  await asyncForEach(members, async (member: FolderMember | ServiceMember) => {
+    const name = member.name
+
+    if (member.type === MemberType.folder) {
+      await createFolder(path.join(destinationPath, name)).catch((err) =>
+        Promise.reject({ error: err, failedToCreate: name })
+      )
+
+      await createFileTree(member.members, [...parentFolders, name]).catch(
+        (err) => Promise.reject({ error: err, failedToCreate: name })
+      )
+    } else {
+      await createFile(path.join(destinationPath, name), member.code).catch(
+        (err) => Promise.reject({ error: err, failedToCreate: name })
+      )
+    }
+  })
+
+  return Promise.resolve()
+}
+
+export const getTreeExample = () => ({
+  message: 'Provided not supported data format.',
+  supportedFormat: {
+    members: [
+      {
+        name: 'jobs',
+        type: 'folder',
+        members: [
+          {
+            name: 'extract',
+            type: 'folder',
+            members: [
+              {
+                name: 'makedata1',
+                type: 'service',
+                code: '%put Hello World!;'
+              }
+            ]
+          }
+        ]
+      }
+    ]
+  }
+})

src/controllers/index.ts

@@ -1,46 +1,2 @@
-import { execFile } from 'child_process'
+export * from './sas'
-import { readFile, generateTimestamp, deleteFile } from '@sasjs/utils'
+export * from './deploy'
-import path from 'path'
-import { ExecutionResult, RequestQuery } from '../types'
-
-// FIXME
-const sasExePath = `C:\\Program Files\\SASHome\\SASFoundation\\9.4\\sas.exe`
-const baseSasLogPath = 'C:\\Users\\YuryShkoda\\projects\\server\\sas\\logs'
-const baseSasCodePath = `sas`
-
-// TODO: create utils isSasFile
-
-export const processSas = async (
-  query: RequestQuery
-): Promise<ExecutionResult> =>
-  new Promise((resolve, reject) => {
-    let sasCodePath = query._program
-    sasCodePath = path.join(baseSasCodePath, `${sasCodePath}.sas`)
-    sasCodePath = sasCodePath.replace(new RegExp('/', 'g'), path.sep)
-
-    const sasFile: string = sasCodePath.split(path.sep).pop() || 'default'
-
-    const sasLogPath = [
-      baseSasLogPath,
-      path.sep,
-      sasFile.replace(/\.sas/g, ''),
-      '-',
-      generateTimestamp(),
-      '.log'
-    ].join('')
-
-    execFile(
-      sasExePath,
-      ['-SYSIN', sasCodePath, '-log', sasLogPath, '-nosplash'],
-      async (err, _, stderr) => {
-        if (err) reject(err)
-        if (stderr) reject(stderr)
-
-        const log = await readFile(sasLogPath)
-
-        deleteFile(sasLogPath)
-
-        resolve({ log: log, logPath: sasLogPath })
-      }
-    )
-  })

src/routes/index.ts

@@ -1,6 +1,6 @@
 import express from 'express'
-import { processSas } from '../controllers'
+import { processSas, createFileTree, getTreeExample } from '../controllers'
-import { ExecutionResult, RequestQuery, isRequestQuery } from '../types'
+import { ExecutionResult, isRequestQuery, isFileTree } from '../types'
 
 const router = express.Router()
 
@@ -20,4 +20,20 @@ router.get('/', async (req, res) => {
 <p>Log:</p> <textarea style="width: 100%; height: 100%">${result.log}</textarea>`)
 })
 
+router.post('/deploy', async (req, res) => {
+  if (!isFileTree(req.body)) {
+    res.status(400).send(getTreeExample())
+
+    return
+  }
+
+  await createFileTree(req.body.members)
+    .then(() => {
+      res.status(200).send('Files deployed successfully to @sasjs/server.')
+    })
+    .catch((err) => {
+      res.status(500).send({ message: 'Deployment failed!', ...err })
+    })
+})
+
 export default router

src/routes/spec/routes.spec.ts

@@ -0,0 +1,97 @@
+import request from 'supertest'
+import app from '../../app'
+import { getTreeExample } from '../../controllers/deploy'
+import { getTmpFilesFolderPath } from '../../utils/file'
+import { folderExists, fileExists, readFile, deleteFolder } from '@sasjs/utils'
+import path from 'path'
+
+describe('deploy', () => {
+  const shouldFailAssertion = async (payload: any) => {
+    const res = await request(app).post('/deploy').send(payload)
+
+    expect(res.statusCode).toEqual(400)
+    expect(res.body).toEqual(getTreeExample())
+  }
+
+  it('should respond with payload example if valid payload was not provided', async () => {
+    await shouldFailAssertion(null)
+    await shouldFailAssertion(undefined)
+    await shouldFailAssertion('data')
+    await shouldFailAssertion({})
+    await shouldFailAssertion({
+      userId: 1,
+      title: 'test is cool'
+    })
+    await shouldFailAssertion({
+      membersWRONG: []
+    })
+    await shouldFailAssertion({
+      members: {}
+    })
+    await shouldFailAssertion({
+      members: [
+        {
+          nameWRONG: 'jobs',
+          type: 'folder',
+          members: []
+        }
+      ]
+    })
+    await shouldFailAssertion({
+      members: [
+        {
+          name: 'jobs',
+          type: 'WRONG',
+          members: []
+        }
+      ]
+    })
+    await shouldFailAssertion({
+      members: [
+        {
+          name: 'jobs',
+          type: 'folder',
+          members: [
+            {
+              name: 'extract',
+              type: 'folder',
+              members: [
+                {
+                  name: 'makedata1',
+                  type: 'service',
+                  codeWRONG: '%put Hello World!;'
+                }
+              ]
+            }
+          ]
+        }
+      ]
+    })
+  })
+
+  it('should respond with payload example if valid payload was not provided', async () => {
+    const res = await request(app)
+      .post('/deploy')
+      .send(getTreeExample().supportedFormat)
+
+    expect(res.statusCode).toEqual(200)
+    expect(res.text).toEqual('Files deployed successfully to @sasjs/server.')
+    await expect(folderExists(getTmpFilesFolderPath())).resolves.toEqual(true)
+
+    const testJobFolder = path.join(getTmpFilesFolderPath(), 'jobs', 'extract')
+    await expect(folderExists(testJobFolder)).resolves.toEqual(true)
+
+    const testJobFile = path.join(
+      testJobFolder,
+      getTreeExample().supportedFormat.members[0].members[0].members[0].name
+    )
+
+    await expect(fileExists(testJobFile)).resolves.toEqual(true)
+
+    await expect(readFile(testJobFile)).resolves.toEqual(
+      getTreeExample().supportedFormat.members[0].members[0].members[0].code
+    )
+
+    await deleteFolder(getTmpFilesFolderPath())
+  })
+})

src/server.ts

@@ -1,9 +1,4 @@
-import express from 'express'
+import app from './app'
-import indexRouter from './routes'
-
-const app = express()
-
-app.use('/', indexRouter)
 
 const port = 5000
 app.listen(port, () => {

src/types/fileTree.ts

@@ -0,0 +1,47 @@
+export interface FileTree {
+  members: [FolderMember, ServiceMember]
+}
+
+export enum MemberType {
+  folder = 'folder',
+  service = 'service'
+}
+
+export interface FolderMember {
+  name: string
+  type: MemberType.folder
+  members: [FolderMember, ServiceMember]
+}
+
+export interface ServiceMember {
+  name: string
+  type: MemberType.service
+  code: string
+}
+
+export const isFileTree = (arg: any): arg is FileTree =>
+  arg &&
+  arg.members &&
+  Array.isArray(arg.members) &&
+  arg.members.filter(
+    (member: FolderMember | ServiceMember) =>
+      !isFolderMember(member) && !isServiceMember(member)
+  ).length === 0
+
+const isFolderMember = (arg: any): arg is FolderMember =>
+  arg &&
+  typeof arg.name === 'string' &&
+  arg.type === MemberType.folder &&
+  arg.members &&
+  Array.isArray(arg.members) &&
+  arg.members.filter(
+    (member: FolderMember | ServiceMember) =>
+      !isFolderMember(member) && !isServiceMember(member)
+  ).length === 0
+
+const isServiceMember = (arg: any): arg is ServiceMember =>
+  arg &&
+  typeof arg.name === 'string' &&
+  arg.type === MemberType.service &&
+  arg.code &&
+  typeof arg.code === 'string'

src/types/index.ts

@@ -1,2 +1,3 @@
 export * from './sas'
 export * from './request'
+export * from './fileTree'

src/utils/file.ts

@@ -0,0 +1,8 @@
+import path from 'path'
+import { getRealPath } from '@sasjs/utils'
+
+export const getTmpFolderPath = () =>
+  getRealPath(path.join(__dirname, '..', '..', 'tmp'))
+
+export const getTmpFilesFolderPath = () =>
+  path.join(getTmpFolderPath(), 'files')