feat: initial version

Author: Elad Ben-Israel

.gitignore

@@ -46,6 +46,8 @@ jspm_packages/
 # exclude typescript compiler outputs
 *.d.ts
 *.js
+# synthesized by projen
+/.eslintrc.json
 !# synthesized by projen, but committed to git
 !/LICENSE
 !/.projenrc.js

.projenrc.js

@@ -1,4 +1,4 @@
-const { TypeScriptLibraryProject, Semver } = require('projen');
+const { TypeScriptLibraryProject, Semver, Jest, Eslint } = require('projen');
 
 const project = new TypeScriptLibraryProject({
   name: 'jsii-srcmak',
@@ -9,13 +9,18 @@ const project = new TypeScriptLibraryProject({
   authorEmail: 'benisrae@amazon.com',
   stability: 'experimental',
   devDependencies: {
-    '@types/node': Semver.caret('10.0.0')
+    '@types/node': Semver.caret('13.9.8'),
+    '@types/fs-extra': Semver.caret('9.0.1'),
   },
   dependencies: {
     'jsii': Semver.pinned('1.1.0'),
     'jsii-pacmak': Semver.pinned('1.1.0'),
+    'fs-extra': Semver.caret('9.0.0')
   },
   releaseToNpm: true
 });
 
+new Jest(project);
+new Eslint(project);
+
 project.synth();

README.md

@@ -0,0 +1,38 @@
+# jsii-srcmak
+
+> Generates jsii source files for multiple languages from TypeScript.
+
+## Usage
+
+Say I have a TypeScript file `source/index.ts`:
+
+```ts
+export interface Operands {
+  readonly lhs: number;
+  readonly rhs: number;
+}
+
+export class Calc {
+  public add(ops: Operands): number {
+    return ops.lhs + ops.rhs;
+  }
+
+  public mul(ops: Operands): number {
+    return ops.lhs * opts.rhs;
+  }
+}
+```
+
+The following invocation will generate `target/my_python_module` with `Calc` in python:
+
+```ts
+import { srcmak } from 'jsii-srcmak';
+
+await srcmak('source', 'target', {
+  pythonName: 'my_python_module'
+});
+```
+
+## License
+
+Distributed under the [Apache 2.0](./LICENSE) license.

lib/compile.ts

@@ -0,0 +1,70 @@
+import * as fs from 'fs-extra';
+import * as path from 'path';
+import { exec } from './util';
+import { Options } from './options';
+
+const compilerModule = require.resolve('jsii/bin/jsii');
+
+/**
+ * Compiles the source files in `workdir` with jsii.
+ */
+export async function compile(workdir: string, options: Options) {
+  const args = [ '--silence-warnings', 'reserved-word' ];
+  const entrypoint = options.entrypoint ?? 'index.ts';
+
+  if (path.extname(entrypoint) !== '.ts') {
+    throw new Error(`jsii entrypoint must be a .ts file: ${entrypoint}`);
+  }
+
+  // path to entrypoint without extension
+  const basepath = path.join(path.dirname(entrypoint), path.basename(entrypoint, '.ts'));
+
+  // jsii modules to include
+  const modules = options.modules ?? [];
+
+  const targets: Record<string, any> = { };
+
+  const deps: Record<string, string> = { };
+  for (const mod of modules) {
+    if (mod.startsWith('@types/')) {
+      continue;
+    }
+
+    deps[mod] = '*';
+  }
+
+  const pkg = {
+    name: 'generated',
+    version: '0.0.0',
+    author: 'generated@generated.com',
+    main: `${basepath}.js`,
+    types: `${basepath}.d.ts`,
+    license: 'Apache-2.0',
+    repository: { url: 'http://generated', type: 'git' },
+    jsii: {
+      outdir: 'dist',
+      targets: targets,
+    },
+    dependencies: deps,
+    peerDependencies: deps,
+  };
+
+  if (options.pythonName) {
+    targets.python = {
+      distName: 'generated',
+      module: options.pythonName,
+    };
+  }
+
+  for (const mod of modules) {
+    const sourcedir = path.dirname(require.resolve(`${mod}/package.json`));
+    await fs.mkdirp(path.join(workdir, path.join('node_modules', path.dirname(mod))));
+    await fs.ensureSymlink(sourcedir, path.join(workdir, 'node_modules', mod));
+  }
+
+  await fs.writeFile(path.join(workdir, 'package.json'), JSON.stringify(pkg, undefined, 2));
+
+  await exec(compilerModule, args, {
+    cwd: workdir,
+  });
+}

lib/index.ts

@@ -1 +1,2 @@
-console.log('hi');
+export * from './srcmak';
+export * from './compile';

lib/options.ts

@@ -0,0 +1,18 @@
+export interface Options {
+  /**
+   * The relative path of the .ts entrypoint within the source directory.
+   * @default "index.ts"
+   */
+  entrypoint?: string;
+
+  /**
+   * The name of the the python module to generate. If omitted python will not be generated.
+   */
+  pythonName?: string;
+
+  /**
+   * List of module names to compile against. These modules must be resolvable
+   * against the current executable and their version will be the same version.
+   */
+  modules?: string[];
+}

lib/srcmak.ts

@@ -0,0 +1,31 @@
+import * as fs from 'fs-extra';
+import * as path from 'path';
+import { withTempDir, exec } from './util';
+import { compile } from './compile';
+import { Options } from './options';
+
+const pacmakModule = require.resolve('jsii-pacmak/bin/jsii-pacmak');
+
+export async function srcmak(srcdir: string, targetdir: string, options: Options) {
+  srcdir = path.resolve(srcdir);
+  targetdir = path.resolve(targetdir);
+
+  await withTempDir('jsii-codemak', async () => {
+    // copy sources to temp directory
+    await fs.copy(srcdir, '.');
+
+    // perform jsii compilation
+    await compile('.', options);
+
+    // run pacmak to generate code
+    await exec(pacmakModule, [ '--code-only' ]);
+
+    // extract code based on selected languages
+    if (options.pythonName) {
+      const reldir = options.pythonName.replace(/\./g, '/'); // replace "." with "/"
+      const source = path.resolve(`dist/python/src/${reldir}`);
+      const target = path.join(targetdir, reldir);
+      await fs.move(source, target, { overwrite: true });
+    }
+  });
+}

lib/util.ts

@@ -0,0 +1,63 @@
+import * as fs from 'fs-extra';
+import * as path from 'path';
+import * as os from 'os';
+import { spawn, SpawnOptions } from 'child_process';
+
+export async function withTempDir(dirname: string, closure: (dir: string) => Promise<void>) {
+  const prevdir = process.cwd();
+  const parent = await fs.mkdtemp(path.join(os.tmpdir(), 'cdk8s.'));
+  const workdir = path.join(parent, dirname);
+  await fs.mkdirp(workdir);
+  try {
+    process.chdir(workdir);
+    await closure(workdir);
+
+    if (!process.env.WITH_TEMP_DIR_RETAIN) {
+      await fs.remove(parent);
+    } else {
+      console.error(`retained temp dir: ${parent}`);
+    }
+  } catch(e) {
+    console.error(`retained temp dir due to an error: ${parent}`);
+    throw e;
+  } finally {
+    process.chdir(prevdir);
+  }
+}
+
+export async function exec(moduleName: string, args: string[] = [], options: SpawnOptions = { }) {
+  return new Promise((ok, fail) => {
+
+    const opts: SpawnOptions = {
+      ...options,
+      stdio: [ 'inherit', 'pipe', 'pipe' ],
+    };
+    const child = spawn(process.execPath, [ moduleName, ...args ], opts);
+
+    const data = new Array<Buffer>();
+    child.stdout?.on('data', chunk => data.push(chunk));
+    child.stderr?.on('data', chunk => data.push(chunk));
+
+    const newError = (message: string) => new Error([
+      message,
+      `COMMAND: ${moduleName} ${args.join(' ')}`,
+      `WORKDIR: ${path.resolve(options.cwd ?? '.')}`,
+      '------------------------------------------------------------------------------------',
+      Buffer.concat(data).toString('utf-8'),
+      '------------------------------------------------------------------------------------',
+    ].join('\n'));
+
+    child.once('error', err => {
+      throw newError(`jsii compilation failed. error: ${err.message}`);
+    });
+
+    child.once('exit', code => {
+      if (code === 0) {
+        return ok();
+      }
+      else {
+        return fail(newError(`jsii compilation failed with non-zero exit code: ${code}`));
+      }
+    });
+  });
+}

test/__snapshots__/jsii-srcmak.test.js.snap

@@ -0,0 +1,83 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`python + different entrypoint + submodule 1`] = `
+Object {
+  "my_python_module/submodule/__init__.py": "import abc
+import builtins
+import datetime
+import enum
+import typing
+
+import jsii
+import jsii.compat
+import publication
+
+__jsii_assembly__ = jsii.JSIIAssembly.load(\\"generated\\", \\"0.0.0\\", __name__, \\"generated@0.0.0.jsii.tgz\\")
+
+
+class Hello(metaclass=jsii.JSIIMeta, jsii_type=\\"generated.Hello\\"):
+    def __init__(self) -> None:
+        jsii.create(Hello, self, [])
+
+    @jsii.member(jsii_name=\\"add\\")
+    def add(self, *, lhs: jsii.Number, rhs: jsii.Number) -> jsii.Number:
+        \\"\\"\\"
+        :param lhs: -
+        :param rhs: -
+        \\"\\"\\"
+        ops = Operands(lhs=lhs, rhs=rhs)
+
+        return jsii.invoke(self, \\"add\\", [ops])
+
+
+@jsii.data_type(jsii_type=\\"generated.Operands\\", jsii_struct_bases=[], name_mapping={'lhs': 'lhs', 'rhs': 'rhs'})
+class Operands():
+    def __init__(self, *, lhs: jsii.Number, rhs: jsii.Number):
+        \\"\\"\\"
+        :param lhs: -
+        :param rhs: -
+        \\"\\"\\"
+        self._values = {
+            'lhs': lhs,
+            'rhs': rhs,
+        }
+
+    @builtins.property
+    def lhs(self) -> jsii.Number:
+        return self._values.get('lhs')
+
+    @builtins.property
+    def rhs(self) -> jsii.Number:
+        return self._values.get('rhs')
+
+    def __eq__(self, rhs) -> bool:
+        return isinstance(rhs, self.__class__) and rhs._values == self._values
+
+    def __ne__(self, rhs) -> bool:
+        return not (rhs == self)
+
+    def __repr__(self) -> str:
+        return 'Operands(%s)' % ', '.join(k + '=' + repr(v) for k, v in self._values.items())
+
+
+__all__ = [\\"Hello\\", \\"Operands\\", \\"__jsii_assembly__\\"]
+
+publication.publish()
+",
+  "my_python_module/submodule/_jsii/__init__.py": "import abc
+import builtins
+import datetime
+import enum
+import typing
+
+import jsii
+import jsii.compat
+import publication
+__all__ = []
+
+publication.publish()
+",
+  "my_python_module/submodule/py.typed": "
+",
+}
+`;