@stepzen/transpiler 0.28.0-experimental.dd6fead → 0.28.0-experimental.f225ee8

package/src/actions/stitch.ts

@@ -1,6 +1,6 @@
 import {clone, cloneDeep} from 'lodash'
 import {parse, print, visit} from 'graphql'
-import * as fs from 'fs-extra'
+import * as fsx from 'fs-extra'
 import * as glob from 'glob'
 import * as os from 'os'
 import * as path from 'path'
@@ -9,15 +9,13 @@ import * as prettier from 'prettier'
 import dedupeQueryAndMutationTypes from '../utils/dedupe-query-and-mutation-types'
 import {ALL_GRAPHQL_FILES} from '../utils/constants'
 import {getAllGraphQLFiles} from '../utils/copy-workspace-content'
+import {rmtemp} from '../utils/rmtemp'
 
-export default (
-  source: string,
-  output: string = path.join(os.tmpdir(), `stepzen-tmp-${Date.now()}`),
-) => {
+const doStitch = (source: string, output: string) => {
   // Ensure source and output directories exist
-  if (!fs.existsSync(source))
+  if (!fsx.existsSync(source))
     throw new Error(`Cannot find source directory ${source}`)
-  fs.ensureDirSync(output)
+  fsx.ensureDirSync(output, 0o700)
 
   // Get a list of files.
   let ast: any
@@ -26,8 +24,8 @@ export default (
   // If there's an index.graphQL - get files argument in @sdl directive
   const sourceIndex = path.join(source, 'index.graphql')
 
-  if (fs.existsSync(sourceIndex)) {
-    const index = fs.readFileSync(sourceIndex, 'utf8')
+  if (fsx.existsSync(sourceIndex)) {
+    const index = fsx.readFileSync(sourceIndex, 'utf8')
     ast = parse(index)
     ast = visit(ast, {
       Directive(node) {
@@ -58,7 +56,7 @@ export default (
     const content = glob
       .sync('**/*.graphql', {cwd: source})
       .map((file: string) => {
-        const graphql = fs.readFileSync(`${source}/${file}`, 'utf8')
+        const graphql = fsx.readFileSync(`${source}/${file}`, 'utf8')
         return graphql
       })
     ast = parse(content.join(os.EOL))
@@ -74,7 +72,7 @@ export default (
   // Check all the files exist
   for (const file of files) {
     const find = path.join(source, file)
-    if (!fs.existsSync(find)) {
+    if (!fsx.existsSync(find)) {
       throw new Error(
         `Cannot find file ${file} referenced in the @sdl directive in index.graphql`,
       )
@@ -86,7 +84,7 @@ export default (
   let stitched = `${printed}${os.EOL}`
   for (const file of files) {
     const find = path.join(source, file)
-    const content = fs.readFileSync(find, 'utf8')
+    const content = fsx.readFileSync(find, 'utf8')
     stitched += `${content}${os.EOL}`
   }
 
@@ -98,16 +96,35 @@ export default (
 
   // Write to output folder
   const outputIndex = path.join(output, 'index.graphql')
-  fs.writeFileSync(outputIndex, stitched)
+  fsx.writeFileSync(outputIndex, stitched)
 
   // Copy config if exists, too
   const sourceConfig = path.join(source, 'config.yaml')
   const outputConfig = path.join(output, 'config.yaml')
 
-  if (fs.existsSync(sourceConfig)) {
-    fs.copyFileSync(sourceConfig, outputConfig)
+  if (fsx.existsSync(sourceConfig)) {
+    fsx.copyFileSync(sourceConfig, outputConfig)
   }
 
   // Return output folder
   return output
 }
+
+const stitch = (source: string, output?: string) => {
+  if (output) {
+    return doStitch(source, output)
+  }
+
+  output = path.join(os.tmpdir(), `stepzen-tmp-${Date.now()}`)
+  try {
+    return doStitch(source, output)
+  } catch (error) {
+    // In case of an error delete the temp output folder created earlier so that
+    // it does not "leak". In case of a success, deleting the output folder is
+    // the caller responsibility.
+    rmtemp(output)
+    throw error
+  }
+}
+
+export default stitch

package/src/actions/transpile.ts

@@ -1,4 +1,4 @@
-import {DocumentNode, parse} from 'graphql'
+import {parse} from 'graphql'
 import * as dotenv from 'dotenv'
 import * as debug from 'debug'
 import * as fs from 'fs'
@@ -10,6 +10,7 @@ import stitch from '../actions/stitch'
 import configure from './configure'
 
 import configMutations from '../mutations/config'
+import {rmtemp} from '../utils/rmtemp'
 
 /**
  * Read a StepZen workspace directory, apply StepZen-specific schema and config
@@ -61,9 +62,13 @@ export default async (source: string) => {
 
   if (graphqlFiles.length > 0) {
     const stitched = await stitch(source)
-    const index = path.join(stitched, 'index.graphql')
-    const graphql = fs.readFileSync(index, 'utf8')
-    schema = print(parse(graphql))
+    try {
+      const index = path.join(stitched, 'index.graphql')
+      const graphql = fs.readFileSync(index, 'utf8')
+      schema = print(parse(graphql))
+    } finally {
+      rmtemp(stitched)
+    }
   }
 
   return {

package/src/actions/validate.ts

@@ -1,5 +1,5 @@
 import {buildASTSchema, DocumentNode, parse, print} from 'graphql'
-import * as fs from 'fs-extra'
+import * as fsx from 'fs-extra'
 import * as os from 'os'
 import * as path from 'path'
 
@@ -16,18 +16,18 @@ export default (
   },
 ) => {
   // Ensure source and output directories exist
-  if (!fs.existsSync(source)) {
+  if (!fsx.existsSync(source)) {
     throw new Error(`Cannot find source directory ${source}`)
   }
 
   // Ensure index.graphql exists
-  if (!fs.existsSync(`${source}/index.graphql`)) {
+  if (!fsx.existsSync(`${source}/index.graphql`)) {
     throw new Error(`Cannot find index.graphql in ${source}`)
   }
 
   // Get the index.graphql file
   const file = path.join(source, 'index.graphql')
-  const index = fs.readFileSync(file, 'utf8')
+  const index = fsx.readFileSync(file, 'utf8')
 
   // Parse
   let ast: DocumentNode = parse(

package/src/utils/copy-workspace-content.ts

@@ -1,4 +1,4 @@
-import * as fs from 'fs-extra'
+import * as fsx from 'fs-extra'
 import * as glob from 'glob'
 import * as path from 'path'
 import {flatMap} from 'lodash'
@@ -24,7 +24,7 @@ const IGNORED_PATTERNS = ['node_modules/**']
  * Exclude special folders, e.g. node_modules
  */
 export default (srcPath: string, dstPath: string) => {
-  if (!fs.existsSync(srcPath)) {
+  if (!fsx.existsSync(srcPath)) {
     throw new Error(`Cannot find source directory ${srcPath}`)
   }
 
@@ -36,8 +36,8 @@ export default (srcPath: string, dstPath: string) => {
   ).forEach(relativePath => {
     const srcFileFullPath = path.join(srcPath, relativePath)
     const dstFileFullPath = path.join(dstPath, relativePath)
-    fs.ensureDirSync(path.dirname(dstFileFullPath))
-    fs.copyFileSync(srcFileFullPath, dstFileFullPath)
+    fsx.ensureDirSync(path.dirname(dstFileFullPath))
+    fsx.copyFileSync(srcFileFullPath, dstFileFullPath)
   })
 }
 

package/src/utils/merge-helpers.ts

@@ -2,7 +2,7 @@ import * as debug from 'debug'
 import {BREAK, GraphQLSchema, visit} from 'graphql'
 import {buildSchema} from 'graphql/utilities'
 import fetch from '@stepzen/fetch'
-import * as fs from 'fs-extra'
+import * as fsx from 'fs-extra'
 import * as glob from 'glob'
 import * as os from 'os'
 import * as path from 'path'
@@ -13,6 +13,7 @@ import {STEPZEN_SERVER_URL} from './constants'
 
 import configure from '../actions/configure'
 import transpile from '../actions/transpile'
+import {rmtemp} from './rmtemp'
 
 export const dedupeTempFolder = (dirpath: string) => {
   do {
@@ -27,7 +28,7 @@ export const dedupeTempFolder = (dirpath: string) => {
 export const findNextAvailableSubfolder = (folder: string, name: string) => {
   let subfolder = name
   let counter = 1
-  while (fs.existsSync(path.join(folder, subfolder))) {
+  while (fsx.existsSync(path.join(folder, subfolder))) {
     const suffix = `${counter++}`.padStart(2, '0')
     subfolder = `${name}-${suffix}`
   }
@@ -76,30 +77,33 @@ export const getConfiguration = async (
   answers: any = {},
 ): Promise<string | boolean> => {
   const tmp = path.join(os.tmpdir(), `stepzen-tmp-config-${Date.now()}`)
-  fs.ensureDirSync(tmp)
+  fsx.ensureDirSync(tmp)
 
-  for (const directory of directories) {
-    const configs = [
-      ...glob.sync('**/config.yaml', {cwd: directory}),
-      ...glob.sync('**/stepzen.config.json', {cwd: directory}),
-    ]
+  try {
+    for (const directory of directories) {
+      const configs = [
+        ...glob.sync('**/config.yaml', {cwd: directory}),
+        ...glob.sync('**/stepzen.config.json', {cwd: directory}),
+      ]
 
-    for (const config of configs) {
-      const configFolder = path.join(directory, config)
+      for (const config of configs) {
+        const configFolder = path.join(directory, config)
 
-      let writeFolder = path.join(tmp, directory, config)
-      writeFolder = dedupeTempFolder(writeFolder)
+        let writeFolder = path.join(tmp, directory, config)
+        writeFolder = dedupeTempFolder(writeFolder)
 
-      const content = fs.readFileSync(configFolder, 'utf8')
+        const content = fsx.readFileSync(configFolder, 'utf8')
 
-      fs.ensureFileSync(writeFolder)
-      fs.writeFileSync(writeFolder, content)
+        fsx.ensureFileSync(writeFolder)
+        fsx.writeFileSync(writeFolder, content, {mode: 0o600})
+      }
     }
-  }
 
-  const configuration = await configure(tmp, silent, answers)
-  fs.removeSync(tmp)
-  return configuration
+    const configuration = await configure(tmp, silent, answers)
+    return configuration
+  } finally {
+    rmtemp(tmp)
+  }
 }
 
 export const getExtensions = async (): Promise<string> => {

package/src/utils/rmtemp.ts

@@ -0,0 +1,48 @@
+// Copyright (c) 2020,2021,2022,2023, StepZen, Inc.
+
+import * as fs from 'fs'
+import * as path from 'path'
+import * as os from 'os'
+import * as debug from 'debug'
+
+// ----------------------------------------------------------------------------
+//      THIS ENTIRE FILE IS COPIED FROM packages/cli/src/shared/rmtemp.ts
+// (because there is no effective way to share util classes between packages yet)
+// ----------------------------------------------------------------------------
+
+/**
+ * Verify that the given path is indeed inside the tmp folder,
+ * and delete it recursively suppressing any errors.
+ *
+ * If the given path is not inside the tmp folder, do nothing.
+ *
+ * @param {*} fileOrDirPath path to a temp file or folder to delete
+ */
+export const rmtemp = (fileOrDirPath?: string) => {
+  if (!fileOrDirPath) {
+    return
+  }
+
+  // https://stackoverflow.com/a/45242825
+  const relative = path.relative(os.tmpdir(), fileOrDirPath)
+  const isInTemp =
+    relative && !relative.startsWith('..') && !path.isAbsolute(relative)
+
+  if (isInTemp) {
+    try {
+      fs.rmSync(fileOrDirPath, {recursive: true, force: true})
+    } catch (error) {
+      // ignore errors
+      debug('stepzen:rmtemp')(
+        `WARN: caught an exception while deleting ${fileOrDirPath}: `,
+        error,
+      )
+    }
+  } else {
+    debug('stepzen:rmtemp')(
+      `WARN: got a temp path ${fileOrDirPath} out of the TMP folder -- ignoring`,
+    )
+  }
+}
+
+export default rmtemp

package/src/utils/set-files-in-sdl.ts

@@ -1,11 +1,14 @@
 import * as fs from 'fs'
 import * as glob from 'glob'
 import {
+  ConstDirectiveNode,
   DirectiveNode,
+  Kind,
   ListValueNode,
   parse,
   SchemaDefinitionNode,
   StringValueNode,
+  OperationTypeNode,
   visit,
 } from 'graphql'
 import * as path from 'path'
@@ -23,28 +26,28 @@ export const createOrUpdateSdlDirective = (
   allGraphQLFiles: readonly string[],
   origSdlDirective?: DeepWriteable<DirectiveNode>,
 ) => {
-  let sdlDirective: DeepWriteable<DirectiveNode>
+  let sdlDirective: DeepWriteable<ConstDirectiveNode>
   if (origSdlDirective) {
     sdlDirective = cloneDeep(origSdlDirective)
   } else {
     sdlDirective = {
-      kind: 'Directive',
+      kind: Kind.DIRECTIVE,
       name: {
-        kind: 'Name',
+        kind: Kind.NAME,
         value: 'sdl',
       },
       arguments: [
         {
-          kind: 'Argument',
+          kind: Kind.ARGUMENT,
           name: {
-            kind: 'Name',
+            kind: Kind.NAME,
             value: 'files',
           },
           value: {
-            kind: 'ListValue',
+            kind: Kind.LIST,
             values: [
               {
-                kind: 'StringValue',
+                kind: Kind.STRING,
                 value: ALL_GRAPHQL_FILES,
               },
             ],
@@ -72,7 +75,7 @@ export const createOrUpdateSdlDirective = (
         allGraphQLFiles.forEach(file => fileset.add(normalizePathSep(file)))
       }
       filesValueNodes.values = [...fileset].map(file => ({
-        kind: 'StringValue',
+        kind: Kind.STRING,
         value: file,
       }))
     }
@@ -87,18 +90,18 @@ export const createSchemaElement = (
   allGraphQLFiles: readonly string[],
 ) => {
   const schemaElement: DeepWriteable<SchemaDefinitionNode> = {
-    kind: 'SchemaDefinition',
+    kind: Kind.SCHEMA_DEFINITION,
     directives: [
       createOrUpdateSdlDirective(importedGraphQLFiles, allGraphQLFiles),
     ],
     operationTypes: [
       {
-        kind: 'OperationTypeDefinition',
-        operation: 'query',
+        kind: Kind.OPERATION_TYPE_DEFINITION,
+        operation: OperationTypeNode.QUERY,
         type: {
-          kind: 'NamedType',
+          kind: Kind.NAMED_TYPE,
           name: {
-            kind: 'Name',
+            kind: Kind.NAME,
             value: 'Query',
           },
         },