@shopify/create-app 0.5.2 → 0.6.0

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # @shopify/create-app
 
+## 0.6.0
+
+### Minor Changes
+
+- 011cd5e: Implement the create-app workflow
+- 7b69661: Bundle the CLI using Rollup
+
 ## 0.5.2
 
 ### Patch Changes

package/bin/{dev → create-app-dev}

@@ -1,13 +1,13 @@
 #!/usr/bin/env node
 
 if (!process.argv.includes("init")) {
-  process.argv.push('init');
+  process.argv.splice(2, 0, 'init');
 }
 
 const oclif = require('@oclif/core')
 
 const path = require('path')
-const project = path.join(__dirname, '..', 'tsconfig.json')
+const project = path.join(__dirname, '..', 'tsconfig.dist.json')
 
 // In dev mode -> use ts-node and dev plugins
 process.env.NODE_ENV = 'development'

package/bin/create-app-dev.cmd

@@ -0,0 +1,3 @@
+@echo off
+
+node "%~dp0\create-app-dev" %*

package/bin/create-app-run.cmd

@@ -0,0 +1,3 @@
+@echo off
+
+node "%~dp0\create-app-run" %*

package/dist/commands/init.js

@@ -1,43 +1,560 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const listr_1 = __importDefault(require("listr"));
-const core_1 = require("@oclif/core");
-class Init extends core_1.Command {
-    async run() {
-        const tasks = new listr_1.default([
-            {
-                title: 'Git',
-                task: () => {
-                    return new listr_1.default([
-                        {
-                            title: 'Cloning the template',
-                            task: () => new Promise((resolve) => setTimeout(resolve, 3000)),
-                        },
-                    ], { concurrent: true });
-                },
-            },
-            {
-                title: 'Initializing the content',
-                task: () => new Promise((resolve) => setTimeout(resolve, 3000)),
-            },
-            {
-                title: 'Installing dependencies',
-                task: () => new Promise((resolve) => setTimeout(resolve, 3000)),
-            },
-        ]);
-        tasks
-            .run()
-            .then(() => {
-            console.log('The app has been successfully created');
-        })
-            .catch((err) => {
-            console.error(err);
-        });
+'use strict';
+
+var core = require('@oclif/core');
+var path$1 = require('path');
+var require$$1 = require('fs');
+var require$$2 = require('util');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var path__default = /*#__PURE__*/_interopDefaultLegacy(path$1);
+var require$$1__default = /*#__PURE__*/_interopDefaultLegacy(require$$1);
+var require$$2__default = /*#__PURE__*/_interopDefaultLegacy(require$$2);
+
+function normalizeWindowsPath(input = "") {
+  if (!input.includes("\\")) {
+    return input;
+  }
+  return input.replace(/\\/g, "/");
+}
+
+const _UNC_REGEX = /^[/][/]/;
+const _UNC_DRIVE_REGEX = /^[/][/]([.]{1,2}[/])?([a-zA-Z]):[/]/;
+const _IS_ABSOLUTE_RE = /^\/|^\\|^[a-zA-Z]:[/\\]/;
+const sep = "/";
+const delimiter = ":";
+const normalize = function(path2) {
+  if (path2.length === 0) {
+    return ".";
+  }
+  path2 = normalizeWindowsPath(path2);
+  const isUNCPath = path2.match(_UNC_REGEX);
+  const hasUNCDrive = isUNCPath && path2.match(_UNC_DRIVE_REGEX);
+  const isPathAbsolute = isAbsolute(path2);
+  const trailingSeparator = path2[path2.length - 1] === "/";
+  path2 = normalizeString(path2, !isPathAbsolute);
+  if (path2.length === 0) {
+    if (isPathAbsolute) {
+      return "/";
+    }
+    return trailingSeparator ? "./" : ".";
+  }
+  if (trailingSeparator) {
+    path2 += "/";
+  }
+  if (isUNCPath) {
+    if (hasUNCDrive) {
+      return `//./${path2}`;
+    }
+    return `//${path2}`;
+  }
+  return isPathAbsolute && !isAbsolute(path2) ? `/${path2}` : path2;
+};
+const join = function(...args) {
+  if (args.length === 0) {
+    return ".";
+  }
+  let joined;
+  for (let i = 0; i < args.length; ++i) {
+    const arg = args[i];
+    if (arg.length > 0) {
+      if (joined === void 0) {
+        joined = arg;
+      } else {
+        joined += `/${arg}`;
+      }
+    }
+  }
+  if (joined === void 0) {
+    return ".";
+  }
+  return normalize(joined);
+};
+const resolve = function(...args) {
+  args = args.map((arg) => normalizeWindowsPath(arg));
+  let resolvedPath = "";
+  let resolvedAbsolute = false;
+  for (let i = args.length - 1; i >= -1 && !resolvedAbsolute; i--) {
+    const path2 = i >= 0 ? args[i] : process.cwd();
+    if (path2.length === 0) {
+      continue;
+    }
+    resolvedPath = `${path2}/${resolvedPath}`;
+    resolvedAbsolute = isAbsolute(path2);
+  }
+  resolvedPath = normalizeString(resolvedPath, !resolvedAbsolute);
+  if (resolvedAbsolute && !isAbsolute(resolvedPath)) {
+    return `/${resolvedPath}`;
+  }
+  return resolvedPath.length > 0 ? resolvedPath : ".";
+};
+function normalizeString(path2, allowAboveRoot) {
+  let res = "";
+  let lastSegmentLength = 0;
+  let lastSlash = -1;
+  let dots = 0;
+  let char = null;
+  for (let i = 0; i <= path2.length; ++i) {
+    if (i < path2.length) {
+      char = path2[i];
+    } else if (char === "/") {
+      break;
+    } else {
+      char = "/";
     }
+    if (char === "/") {
+      if (lastSlash === i - 1 || dots === 1) ; else if (dots === 2) {
+        if (res.length < 2 || lastSegmentLength !== 2 || res[res.length - 1] !== "." || res[res.length - 2] !== ".") {
+          if (res.length > 2) {
+            const lastSlashIndex = res.lastIndexOf("/");
+            if (lastSlashIndex === -1) {
+              res = "";
+              lastSegmentLength = 0;
+            } else {
+              res = res.slice(0, lastSlashIndex);
+              lastSegmentLength = res.length - 1 - res.lastIndexOf("/");
+            }
+            lastSlash = i;
+            dots = 0;
+            continue;
+          } else if (res.length !== 0) {
+            res = "";
+            lastSegmentLength = 0;
+            lastSlash = i;
+            dots = 0;
+            continue;
+          }
+        }
+        if (allowAboveRoot) {
+          res += res.length > 0 ? "/.." : "..";
+          lastSegmentLength = 2;
+        }
+      } else {
+        if (res.length > 0) {
+          res += `/${path2.slice(lastSlash + 1, i)}`;
+        } else {
+          res = path2.slice(lastSlash + 1, i);
+        }
+        lastSegmentLength = i - lastSlash - 1;
+      }
+      lastSlash = i;
+      dots = 0;
+    } else if (char === "." && dots !== -1) {
+      ++dots;
+    } else {
+      dots = -1;
+    }
+  }
+  return res;
 }
-exports.default = Init;
-Init.description = 'Create a new Shopify app';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5pdC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9jb21tYW5kcy9pbml0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7O0FBQUEsa0RBQTBCO0FBQzFCLHNDQUFvQztBQUVwQyxNQUFxQixJQUFLLFNBQVEsY0FBTztJQUd2QyxLQUFLLENBQUMsR0FBRztRQUNQLE1BQU0sS0FBSyxHQUFHLElBQUksZUFBSyxDQUFDO1lBQ3RCO2dCQUNFLEtBQUssRUFBRSxLQUFLO2dCQUNaLElBQUksRUFBRSxHQUFHLEVBQUU7b0JBQ1QsT0FBTyxJQUFJLGVBQUssQ0FDZDt3QkFDRTs0QkFDRSxLQUFLLEVBQUUsc0JBQXNCOzRCQUM3QixJQUFJLEVBQUUsR0FBRyxFQUFFLENBQUMsSUFBSSxPQUFPLENBQUMsQ0FBQyxPQUFPLEVBQUUsRUFBRSxDQUFDLFVBQVUsQ0FBQyxPQUFPLEVBQUUsSUFBSSxDQUFDLENBQUM7eUJBQ2hFO3FCQUNGLEVBQ0QsRUFBQyxVQUFVLEVBQUUsSUFBSSxFQUFDLENBQ25CLENBQUM7Z0JBQ0osQ0FBQzthQUNGO1lBQ0Q7Z0JBQ0UsS0FBSyxFQUFFLDBCQUEwQjtnQkFDakMsSUFBSSxFQUFFLEdBQUcsRUFBRSxDQUFDLElBQUksT0FBTyxDQUFDLENBQUMsT0FBTyxFQUFFLEVBQUUsQ0FBQyxVQUFVLENBQUMsT0FBTyxFQUFFLElBQUksQ0FBQyxDQUFDO2FBQ2hFO1lBQ0Q7Z0JBQ0UsS0FBSyxFQUFFLHlCQUF5QjtnQkFDaEMsSUFBSSxFQUFFLEdBQUcsRUFBRSxDQUFDLElBQUksT0FBTyxDQUFDLENBQUMsT0FBTyxFQUFFLEVBQUUsQ0FBQyxVQUFVLENBQUMsT0FBTyxFQUFFLElBQUksQ0FBQyxDQUFDO2FBQ2hFO1NBQ0YsQ0FBQyxDQUFDO1FBRUgsS0FBSzthQUNGLEdBQUcsRUFBRTthQUNMLElBQUksQ0FBQyxHQUFHLEVBQUU7WUFDVCxPQUFPLENBQUMsR0FBRyxDQUFDLHVDQUF1QyxDQUFDLENBQUM7UUFDdkQsQ0FBQyxDQUFDO2FBQ0QsS0FBSyxDQUFDLENBQUMsR0FBRyxFQUFFLEVBQUU7WUFDYixPQUFPLENBQUMsS0FBSyxDQUFDLEdBQUcsQ0FBQyxDQUFDO1FBQ3JCLENBQUMsQ0FBQyxDQUFDO0lBQ1AsQ0FBQzs7QUFyQ0gsdUJBc0NDO0FBckNRLGdCQUFXLEdBQUcsMEJBQTBCLENBQUMifQ==
+const isAbsolute = function(p) {
+  return _IS_ABSOLUTE_RE.test(p);
+};
+const toNamespacedPath = function(p) {
+  return normalizeWindowsPath(p);
+};
+const extname = function(p) {
+  return path__default["default"].posix.extname(normalizeWindowsPath(p));
+};
+const relative = function(from, to) {
+  return path__default["default"].posix.relative(normalizeWindowsPath(from), normalizeWindowsPath(to));
+};
+const dirname = function(p) {
+  return path__default["default"].posix.dirname(normalizeWindowsPath(p));
+};
+const format = function(p) {
+  return normalizeWindowsPath(path__default["default"].posix.format(p));
+};
+const basename = function(p, ext) {
+  return path__default["default"].posix.basename(normalizeWindowsPath(p), ext);
+};
+const parse = function(p) {
+  return path__default["default"].posix.parse(normalizeWindowsPath(p));
+};
+
+const _path = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  sep: sep,
+  delimiter: delimiter,
+  normalize: normalize,
+  join: join,
+  resolve: resolve,
+  normalizeString: normalizeString,
+  isAbsolute: isAbsolute,
+  toNamespacedPath: toNamespacedPath,
+  extname: extname,
+  relative: relative,
+  dirname: dirname,
+  format: format,
+  basename: basename,
+  parse: parse
+});
+
+const index = {
+  ..._path
+};
+
+var findUp$1 = {exports: {}};
+
+var locatePath = {exports: {}};
+
+var pLocate$2 = {exports: {}};
+
+var pLimit$2 = {exports: {}};
+
+var pTry$2 = {exports: {}};
+
+const pTry$1 = (fn, ...arguments_) => new Promise(resolve => {
+	resolve(fn(...arguments_));
+});
+
+pTry$2.exports = pTry$1;
+// TODO: remove this in the next major version
+pTry$2.exports.default = pTry$1;
+
+const pTry = pTry$2.exports;
+
+const pLimit$1 = concurrency => {
+	if (!((Number.isInteger(concurrency) || concurrency === Infinity) && concurrency > 0)) {
+		return Promise.reject(new TypeError('Expected `concurrency` to be a number from 1 and up'));
+	}
+
+	const queue = [];
+	let activeCount = 0;
+
+	const next = () => {
+		activeCount--;
+
+		if (queue.length > 0) {
+			queue.shift()();
+		}
+	};
+
+	const run = (fn, resolve, ...args) => {
+		activeCount++;
+
+		const result = pTry(fn, ...args);
+
+		resolve(result);
+
+		result.then(next, next);
+	};
+
+	const enqueue = (fn, resolve, ...args) => {
+		if (activeCount < concurrency) {
+			run(fn, resolve, ...args);
+		} else {
+			queue.push(run.bind(null, fn, resolve, ...args));
+		}
+	};
+
+	const generator = (fn, ...args) => new Promise(resolve => enqueue(fn, resolve, ...args));
+	Object.defineProperties(generator, {
+		activeCount: {
+			get: () => activeCount
+		},
+		pendingCount: {
+			get: () => queue.length
+		},
+		clearQueue: {
+			value: () => {
+				queue.length = 0;
+			}
+		}
+	});
+
+	return generator;
+};
+
+pLimit$2.exports = pLimit$1;
+pLimit$2.exports.default = pLimit$1;
+
+const pLimit = pLimit$2.exports;
+
+class EndError extends Error {
+	constructor(value) {
+		super();
+		this.value = value;
+	}
+}
+
+// The input can also be a promise, so we await it
+const testElement = async (element, tester) => tester(await element);
+
+// The input can also be a promise, so we `Promise.all()` them both
+const finder = async element => {
+	const values = await Promise.all(element);
+	if (values[1] === true) {
+		throw new EndError(values[0]);
+	}
+
+	return false;
+};
+
+const pLocate$1 = async (iterable, tester, options) => {
+	options = {
+		concurrency: Infinity,
+		preserveOrder: true,
+		...options
+	};
+
+	const limit = pLimit(options.concurrency);
+
+	// Start all the promises concurrently with optional limit
+	const items = [...iterable].map(element => [element, limit(testElement, element, tester)]);
+
+	// Check the promises either serially or concurrently
+	const checkLimit = pLimit(options.preserveOrder ? 1 : Infinity);
+
+	try {
+		await Promise.all(items.map(element => checkLimit(finder, element)));
+	} catch (error) {
+		if (error instanceof EndError) {
+			return error.value;
+		}
+
+		throw error;
+	}
+};
+
+pLocate$2.exports = pLocate$1;
+// TODO: Remove this for the next major release
+pLocate$2.exports.default = pLocate$1;
+
+const path = path__default["default"];
+const fs$1 = require$$1__default["default"];
+const {promisify: promisify$1} = require$$2__default["default"];
+const pLocate = pLocate$2.exports;
+
+const fsStat = promisify$1(fs$1.stat);
+const fsLStat = promisify$1(fs$1.lstat);
+
+const typeMappings = {
+	directory: 'isDirectory',
+	file: 'isFile'
+};
+
+function checkType({type}) {
+	if (type in typeMappings) {
+		return;
+	}
+
+	throw new Error(`Invalid type specified: ${type}`);
+}
+
+const matchType = (type, stat) => type === undefined || stat[typeMappings[type]]();
+
+locatePath.exports = async (paths, options) => {
+	options = {
+		cwd: process.cwd(),
+		type: 'file',
+		allowSymlinks: true,
+		...options
+	};
+	checkType(options);
+	const statFn = options.allowSymlinks ? fsStat : fsLStat;
+
+	return pLocate(paths, async path_ => {
+		try {
+			const stat = await statFn(path.resolve(options.cwd, path_));
+			return matchType(options.type, stat);
+		} catch (_) {
+			return false;
+		}
+	}, options);
+};
+
+locatePath.exports.sync = (paths, options) => {
+	options = {
+		cwd: process.cwd(),
+		allowSymlinks: true,
+		type: 'file',
+		...options
+	};
+	checkType(options);
+	const statFn = options.allowSymlinks ? fs$1.statSync : fs$1.lstatSync;
+
+	for (const path_ of paths) {
+		try {
+			const stat = statFn(path.resolve(options.cwd, path_));
+
+			if (matchType(options.type, stat)) {
+				return path_;
+			}
+		} catch (_) {
+		}
+	}
+};
+
+var pathExists = {exports: {}};
+
+const fs = require$$1__default["default"];
+const {promisify} = require$$2__default["default"];
+
+const pAccess = promisify(fs.access);
+
+pathExists.exports = async path => {
+	try {
+		await pAccess(path);
+		return true;
+	} catch (_) {
+		return false;
+	}
+};
+
+pathExists.exports.sync = path => {
+	try {
+		fs.accessSync(path);
+		return true;
+	} catch (_) {
+		return false;
+	}
+};
+
+(function (module) {
+const path = path__default["default"];
+const locatePath$1 = locatePath.exports;
+const pathExists$1 = pathExists.exports;
+
+const stop = Symbol('findUp.stop');
+
+module.exports = async (name, options = {}) => {
+	let directory = path.resolve(options.cwd || '');
+	const {root} = path.parse(directory);
+	const paths = [].concat(name);
+
+	const runMatcher = async locateOptions => {
+		if (typeof name !== 'function') {
+			return locatePath$1(paths, locateOptions);
+		}
+
+		const foundPath = await name(locateOptions.cwd);
+		if (typeof foundPath === 'string') {
+			return locatePath$1([foundPath], locateOptions);
+		}
+
+		return foundPath;
+	};
+
+	// eslint-disable-next-line no-constant-condition
+	while (true) {
+		// eslint-disable-next-line no-await-in-loop
+		const foundPath = await runMatcher({...options, cwd: directory});
+
+		if (foundPath === stop) {
+			return;
+		}
+
+		if (foundPath) {
+			return path.resolve(directory, foundPath);
+		}
+
+		if (directory === root) {
+			return;
+		}
+
+		directory = path.dirname(directory);
+	}
+};
+
+module.exports.sync = (name, options = {}) => {
+	let directory = path.resolve(options.cwd || '');
+	const {root} = path.parse(directory);
+	const paths = [].concat(name);
+
+	const runMatcher = locateOptions => {
+		if (typeof name !== 'function') {
+			return locatePath$1.sync(paths, locateOptions);
+		}
+
+		const foundPath = name(locateOptions.cwd);
+		if (typeof foundPath === 'string') {
+			return locatePath$1.sync([foundPath], locateOptions);
+		}
+
+		return foundPath;
+	};
+
+	// eslint-disable-next-line no-constant-condition
+	while (true) {
+		const foundPath = runMatcher({...options, cwd: directory});
+
+		if (foundPath === stop) {
+			return;
+		}
+
+		if (foundPath) {
+			return path.resolve(directory, foundPath);
+		}
+
+		if (directory === root) {
+			return;
+		}
+
+		directory = path.dirname(directory);
+	}
+};
+
+module.exports.exists = pathExists$1;
+
+module.exports.sync.exists = pathExists$1.sync;
+
+module.exports.stop = stop;
+}(findUp$1));
+
+var findUp = findUp$1.exports;
+
+function findPathUp(path, from, type) {
+  return findUp(path, { cwd: from, type });
+}
+
+class FatalError extends Error {
+  constructor(message, tryMessage = null) {
+    super(message);
+    this.tryMessage = tryMessage;
+  }
+}
+class BugError extends FatalError {
+}
+
+async function template(name) {
+  const templatePath = await findPathUp(`templates/${name}`, __dirname, "directory");
+  if (templatePath) {
+    return templatePath;
+  } else {
+    throw new BugError(`Couldn't find the template ${name} in @shopify/create-app.`);
+  }
+}
+
+async function init(_) {
+  console.log("it works");
+}
+
+const _Init = class extends core.Command {
+  async run() {
+    const templatePath = await template("app");
+    const { flags } = await this.parse(_Init);
+    const directory = flags.path ? index.resolve(flags.path) : process.cwd();
+    await init({
+      name: flags.name,
+      templatePath,
+      directory
+    });
+  }
+};
+let Init = _Init;
+Init.description = "Create a new Shopify app";
+Init.flags = {
+  name: core.Flags.string({
+    char: "n",
+    description: "The name of the app to be initialized.",
+    hidden: false
+  }),
+  path: core.Flags.string({
+    char: "p",
+    description: "The path to the directory where the app will be created.",
+    hidden: false
+  })
+};
+
+module.exports = Init;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shopify/create-app",
-  "version": "0.5.2",
+  "version": "0.6.0",
   "private": false,
   "description": "A CLI tool to create a new Shopify app.",
   "keywords": [
@@ -12,7 +12,7 @@
   "license": "MIT",
   "types": "dist/index.d.ts",
   "bin": {
-    "create-app": "./bin/run"
+    "create-app": "./bin/create-app-run"
   },
   "files": [
     "/bin",
@@ -25,8 +25,9 @@
     "@shopify:registry": "https://registry.npmjs.org"
   },
   "scripts": {
-    "build": "shx rm -rf dist && tsc -b",
-    "build:watch": "tsc -b --watch",
+    "clean": "shx rm -rf dist",
+    "build": "shx rm -rf dist && rollup -c",
+    "build:watch": "tsc -b tsconfig.dist.json --watch",
     "prepublishOnly": "yarn run build",
     "lint": "prettier -c src/** && eslint src/**",
     "lint:fix": "prettier src/** && eslint src/** --fix",
@@ -40,17 +41,15 @@
     ]
   },
   "dependencies": {
-    "@bugsnag/js": "^7.14.1",
-    "@oclif/command": "^1",
-    "@oclif/core": "^1",
     "@oclif/plugin-help": "^5",
-    "@oclif/plugin-plugins": "^2.0.1",
-    "@types/listr": "^0.14.4",
-    "listr": "^0.14.3",
-    "@shopify/support": "0.5.2"
+    "@oclif/core": "^1",
+    "@bugsnag/js": "^7.14.1",
+    "plop": "^2.7.6"
   },
   "devDependencies": {
-    "@oclif/test": "^2"
+    "@shopify/core": "0.5.2",
+    "@types/listr": "^0.14.4",
+    "listr": "^0.14.3"
   },
   "engine-strict": true,
   "engines": {
@@ -63,8 +62,6 @@
   ],
   "oclif": {
     "bin": "create-app",
-    "commands": "./dist/commands",
-    "plugins": [],
-    "topicSeparator": " "
+    "commands": "./dist/commands"
   }
 }

package/bin/dev.cmd

@@ -1,3 +0,0 @@
-@echo off
-
-node "%~dp0\dev" %*

package/bin/run.cmd

@@ -1,3 +0,0 @@
-@echo off
-
-node "%~dp0\run" %*

package/dist/commands/init.d.ts

@@ -1,5 +0,0 @@
-import { Command } from '@oclif/core';
-export default class Init extends Command {
-    static description: string;
-    run(): Promise<void>;
-}

package/dist/index.d.ts

@@ -1 +0,0 @@
-export { run } from '@oclif/core';

package/dist/index.js

@@ -1,6 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.run = void 0;
-var core_1 = require("@oclif/core");
-Object.defineProperty(exports, "run", { enumerable: true, get: function () { return core_1.run; } });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQUEsb0NBQWdDO0FBQXhCLDJGQUFBLEdBQUcsT0FBQSJ9