@akemona-org/create-strapi-starter 3.7.0

package/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2015-present Strapi Solutions SAS
+
+Portions of the Strapi software are licensed as follows:
+
+* All software that resides under an "ee/" directory (the “EE Software”), if that directory exists, is licensed under the license defined in "ee/LICENSE".
+
+* All software outside of the above-mentioned directories or restrictions above is available under the "MIT Expat" license as set forth below.
+
+MIT Expat License
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,35 @@
+# Create strapi starter
+
+This package includes the `create-strapi-starter` CLI to simplify creating a Strapi project using starters and templates
+
+## How to use
+
+### Quick usage (recommended)
+
+Using yarn create command
+
+```
+yarn create strapi-starter my-project starter-url
+```
+
+Using npx
+
+```
+npx create-strapi-starter my-project starter-url
+```
+
+### Manual install
+
+Using yarn
+
+```
+yarn global add create-strapi-app
+create-strapi-starter my-project starter-url
+```
+
+Using npm
+
+```
+npm install -g create-strapi-app
+create-strapi-starter my-project starter-url
+```

package/create-strapi-starter.js

@@ -0,0 +1,76 @@
+'use strict';
+
+const commander = require('commander');
+
+const packageJson = require('./package.json');
+const buildStarter = require('./utils/build-starter');
+const promptUser = require('./utils/prompt-user');
+
+const program = new commander.Command(packageJson.name);
+
+program
+  .version(packageJson.version)
+  .arguments('[directory], [starterurl]')
+  .option('--use-npm', 'Force usage of npm instead of yarn to create the project')
+  .option('--debug', 'Display database connection error')
+  .option('--quickstart', 'Quickstart app creation')
+  .option('--dbclient <dbclient>', 'Database client')
+  .option('--dbhost <dbhost>', 'Database host')
+  .option('--dbsrv <dbsrv>', 'Database srv')
+  .option('--dbport <dbport>', 'Database port')
+  .option('--dbname <dbname>', 'Database name')
+  .option('--dbusername <dbusername>', 'Database username')
+  .option('--dbpassword <dbpassword>', 'Database password')
+  .option('--dbssl <dbssl>', 'Database SSL')
+  .option('--dbauth <dbauth>', 'Authentication Database')
+  .option('--dbfile <dbfile>', 'Database file path for sqlite')
+  .option('--dbforce', 'Overwrite database content if any')
+  .description(
+    'Create a fullstack monorepo application using the strapi backend template specified in the provided starter'
+  )
+  .action((directory, starterUrl, programArgs) => {
+    const projectArgs = { projectName: directory, starterUrl };
+
+    initProject(projectArgs, programArgs);
+  });
+
+function generateApp(projectArgs, programArgs) {
+  if (!projectArgs.projectName || !projectArgs.starterUrl) {
+    console.error(
+      'Please specify the <directory> and <starterurl> of your project when using --quickstart'
+    );
+    // eslint-disable-next-line no-process-exit
+    process.exit(1);
+  }
+
+  return buildStarter(projectArgs, programArgs);
+}
+
+async function initProject(projectArgs, program) {
+  const { projectName, starterUrl } = projectArgs;
+  if (program.quickstart) {
+    return generateApp(projectArgs, program);
+  }
+
+  const prompt = await promptUser(projectName, starterUrl);
+
+  const promptProjectArgs = {
+    projectName: prompt.directory || projectName,
+    starterUrl: prompt.starter || starterUrl,
+  };
+
+  const programArgs = {
+    ...program,
+    quickstart: prompt.quick,
+  };
+
+  return generateApp(promptProjectArgs, programArgs);
+}
+
+try {
+  program.parse(process.argv);
+} catch (err) {
+  if (err.exitCode && err.exitCode != 0) {
+    program.outputHelp();
+  }
+}

package/index.js

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+'use strict';
+
+require('./create-strapi-starter');

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@akemona-org/create-strapi-starter",
+  "publishConfig": {
+    "access": "public"
+  },
+  "version": "3.7.0",
+  "description": "Generate a new Strapi application.",
+  "license": "SEE LICENSE IN LICENSE",
+  "homepage": "https://strapi.akemona.com",
+  "keywords": [
+    "create-strapi-starter",
+    "create",
+    "new",
+    "generate",
+    "strapi"
+  ],
+  "main": "./index.js",
+  "bin": {
+    "create-strapi-starter": "./index.js"
+  },
+  "dependencies": {
+    "@akemona-org/strapi-generate-new": "3.7.0",
+    "chalk": "4.1.1",
+    "ci-info": "3.1.1",
+    "commander": "7.1.0",
+    "execa": "5.0.0",
+    "fs-extra": "9.1.0",
+    "git-url-parse": "13.1.0",
+    "inquirer": "8.1.0",
+    "js-yaml": "4.1.0",
+    "node-fetch": "^2.6.1",
+    "ora": "5.4.0",
+    "tar": "6.1.9"
+  },
+  "scripts": {
+    "test": "echo \"no tests yet\""
+  },
+  "author": {
+    "email": "strapi@akemona.com",
+    "name": "Akemona team",
+    "url": "https://strapi.akemona.com"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/akemona/strapi.git"
+  },
+  "bugs": {
+    "url": "https://github.com/akemona/strapi/issues"
+  },
+  "engines": {
+    "node": ">=10.16.0 <=14.x.x",
+    "npm": ">=6.0.0"
+  },
+  "gitHead": "129a8d6191b55810fd66448dcc47fee829df986c"
+}

package/resources/gitignore

@@ -0,0 +1,114 @@
+############################
+# OS X
+############################
+
+.DS_Store
+.AppleDouble
+.LSOverride
+Icon
+.Spotlight-V100
+.Trashes
+._*
+
+
+############################
+# Linux
+############################
+
+*~
+
+
+############################
+# Windows
+############################
+
+Thumbs.db
+ehthumbs.db
+Desktop.ini
+$RECYCLE.BIN/
+*.cab
+*.msi
+*.msm
+*.msp
+
+
+############################
+# Packages
+############################
+
+*.7z
+*.csv
+*.dat
+*.dmg
+*.gz
+*.iso
+*.jar
+*.rar
+*.tar
+*.zip
+*.com
+*.class
+*.dll
+*.exe
+*.o
+*.seed
+*.so
+*.swo
+*.swp
+*.swn
+*.swm
+*.out
+*.pid
+
+
+############################
+# Logs and databases
+############################
+
+.tmp
+*.log
+*.sql
+*.sqlite
+*.sqlite3
+
+
+############################
+# Misc.
+############################
+
+*#
+ssl
+.idea
+nbproject
+public/uploads/*
+!public/uploads/.gitkeep
+
+############################
+# Node.js
+############################
+
+lib-cov
+lcov.info
+pids
+logs
+results
+node_modules
+.node_history
+
+############################
+# Tests
+############################
+
+testApp
+coverage
+
+############################
+# Strapi
+############################
+
+.env
+license.txt
+exports
+*.cache
+build
+.strapi-updater.json

package/utils/build-starter.js

@@ -0,0 +1,169 @@
+'use strict';
+
+const { resolve, join, basename } = require('path');
+const os = require('os');
+const fse = require('fs-extra');
+
+const ora = require('ora');
+const ciEnv = require('ci-info');
+const chalk = require('chalk');
+
+const generateNewApp = require('@akemona-org/strapi-generate-new');
+
+const hasYarn = require('./has-yarn');
+const { runInstall, runApp, initGit } = require('./child-process');
+const { getRepoInfo, downloadGitHubRepo } = require('./fetch-github');
+const logger = require('./logger');
+const stopProcess = require('./stop-process');
+
+/**
+ * @param  {string} - filePath Path to starter.json file
+ */
+function readStarterJson(filePath, starterUrl) {
+  try {
+    const data = fse.readFileSync(filePath);
+    return JSON.parse(data);
+  } catch (err) {
+    stopProcess(`Could not find ${chalk.yellow('starter.json')} in ${chalk.yellow(starterUrl)}`);
+  }
+}
+
+/**
+ * @param  {string} rootPath - Path to the project directory
+ * @param  {string} projectName - Name of the project
+ */
+async function initPackageJson(rootPath, projectName) {
+  const packageManager = hasYarn() ? 'yarn --cwd' : 'npm run --prefix';
+
+  try {
+    await fse.writeJson(
+      join(rootPath, 'package.json'),
+      {
+        name: projectName,
+        private: true,
+        version: '0.0.0',
+        scripts: {
+          'develop:backend': `${packageManager} backend develop`,
+          'develop:frontend': `wait-on http://localhost:1337/admin && ${packageManager} frontend develop`,
+          develop: 'cross-env FORCE_COLOR=1 npm-run-all -l -p develop:*',
+        },
+        devDependencies: {
+          'npm-run-all': '4.1.5',
+          'wait-on': '5.2.1',
+          'cross-env': '7.0.3',
+        },
+      },
+      {
+        spaces: 2,
+      }
+    );
+  } catch (err) {
+    stopProcess(`Failed to create ${chalk.yellow(`package.json`)} in ${chalk.yellow(rootPath)}`);
+  }
+}
+
+/**
+ * @param  {string} path - The directory path for install
+ */
+async function installWithLogs(path) {
+  const installPrefix = chalk.yellow('Installing dependencies:');
+  const loader = ora(installPrefix).start();
+  const logInstall = (chunk = '') => {
+    loader.text = `${installPrefix} ${chunk.toString().split('\n').join(' ')}`;
+  };
+
+  const runner = runInstall(path);
+  runner.stdout.on('data', logInstall);
+  runner.stderr.on('data', logInstall);
+
+  await runner;
+
+  loader.stop();
+  console.log(`Dependencies installed ${chalk.green('successfully')}.`);
+}
+
+/**
+ * @param  {Object} projectArgs - The arguments for create a project
+ * @param {string|null} projectArgs.projectName - The name/path of project
+ * @param {string|null} projectArgs.starterUrl - The GitHub repo of the starter
+ * @param  {Object} program - Commands for generating new application
+ */
+module.exports = async function buildStarter(programArgs, program) {
+  let { projectName, starterUrl } = programArgs;
+
+  // Fetch repo info
+  const repoInfo = await getRepoInfo(starterUrl);
+  const { fullName } = repoInfo;
+
+  // Create temporary directory for starter
+  const tmpDir = await fse.mkdtemp(join(os.tmpdir(), 'strapi-'));
+
+  // Download repo inside temporary directory
+  await downloadGitHubRepo(repoInfo, tmpDir);
+
+  const starterJson = readStarterJson(join(tmpDir, 'starter.json'), starterUrl);
+
+  // Project directory
+  const rootPath = resolve(projectName);
+  const projectBasename = basename(rootPath);
+
+  try {
+    await fse.ensureDir(rootPath);
+  } catch (error) {
+    stopProcess(`Failed to create ${chalk.yellow(rootPath)}: ${error.message}`);
+  }
+
+  // Copy the downloaded frontend folder to the project folder
+  const frontendPath = join(rootPath, 'frontend');
+
+  const starterDir = (await fse.pathExists(join(tmpDir, 'starter'))) ? 'starter' : 'frontend';
+
+  try {
+    await fse.copy(join(tmpDir, starterDir), frontendPath, {
+      overwrite: true,
+      recursive: true,
+    });
+  } catch (error) {
+    stopProcess(`Failed to create ${chalk.yellow(frontendPath)}: ${error.message}`);
+  }
+
+  // Delete temporary directory
+  await fse.remove(tmpDir);
+
+  const fullUrl = `https://github.com/${fullName}`;
+  // Set command options for Strapi app
+  const generateStrapiAppOptions = {
+    ...program,
+    starter: fullUrl,
+    template: starterJson.template,
+    run: false,
+  };
+
+  // Create strapi app using the template
+  await generateNewApp(join(rootPath, 'backend'), generateStrapiAppOptions);
+
+  // Install frontend dependencies
+  console.log(`Creating Strapi starter frontend at ${chalk.green(frontendPath)}.`);
+  console.log(`Installing ${chalk.yellow(fullName)} starter`);
+  await installWithLogs(frontendPath);
+
+  // Setup monorepo
+  initPackageJson(rootPath, projectBasename);
+
+  // Add gitignore
+  try {
+    const gitignore = join(__dirname, '..', 'resources', 'gitignore');
+    await fse.copy(gitignore, join(rootPath, '.gitignore'));
+  } catch (err) {
+    logger.warn(`Failed to create file: ${chalk.yellow('.gitignore')}`);
+  }
+
+  await installWithLogs(rootPath);
+
+  if (!ciEnv.isCI) {
+    await initGit(rootPath);
+  }
+
+  console.log(chalk.green('Starting the app'));
+  await runApp(rootPath);
+};

package/utils/child-process.js

@@ -0,0 +1,60 @@
+'use strict';
+
+const { execSync } = require('child_process');
+const execa = require('execa');
+const hasYarn = require('./has-yarn');
+const logger = require('./logger');
+
+/**
+ * @param  {string} path Path to directory (frontend, backend)
+ */
+function runInstall(path) {
+  if (hasYarn()) {
+    return execa('yarn', ['install'], {
+      cwd: path,
+      stdin: 'ignore',
+    });
+  }
+
+  return execa('npm', ['install'], { cwd: path, stdin: 'ignore' });
+}
+
+function runApp(rootPath) {
+  if (hasYarn()) {
+    return execa('yarn', ['develop'], {
+      stdio: 'inherit',
+      cwd: rootPath,
+    });
+  } else {
+    return execa('npm', ['run', 'develop'], {
+      stdio: 'inherit',
+      cwd: rootPath,
+    });
+  }
+}
+
+async function initGit(rootPath) {
+  try {
+    await execa('git', ['init'], {
+      cwd: rootPath,
+    });
+  } catch (err) {
+    logger.warn(`Could not initialize a git repository`);
+  }
+
+  try {
+    await execa(`git`, [`add`, `-A`], { cwd: rootPath });
+
+    execSync(`git commit -m "Create Strapi starter project"`, {
+      cwd: rootPath,
+    });
+  } catch (err) {
+    logger.warn(`Could not create initial git commit`);
+  }
+}
+
+module.exports = {
+  runInstall,
+  runApp,
+  initGit,
+};

package/utils/fetch-github.js

@@ -0,0 +1,97 @@
+'use strict';
+
+const tar = require('tar');
+const fetch = require('node-fetch');
+const parseGitUrl = require('git-url-parse');
+const chalk = require('chalk');
+
+const stopProcess = require('./stop-process');
+
+function parseShorthand(starter) {
+  // Determine if it is comes from another owner
+  if (starter.includes('/')) {
+    const [owner, partialName] = starter.split('/');
+    const name = `strapi-starter-${partialName}`;
+    return {
+      name,
+      fullName: `${owner}/${name}`,
+    };
+  }
+
+  const name = `strapi-starter-${starter}`;
+  return {
+    name,
+    fullName: `strapi/${name}`,
+  };
+}
+
+/**
+ * @param {string} repo The full name of the repository.
+ */
+async function getDefaultBranch(repo) {
+  const response = await fetch(`https://api.github.com/repos/${repo}`);
+
+  if (!response.ok) {
+    stopProcess(
+      `Could not find the starter information for ${chalk.yellow(
+        repo
+      )}. Make sure it is publicly accessible on github.`
+    );
+  }
+
+  const { default_branch } = await response.json();
+  return default_branch;
+}
+
+/**
+ * @param {string} starter GitHub URL or shorthand to a starter project.
+ */
+async function getRepoInfo(starter) {
+  const { name, full_name: fullName, ref, filepath, protocols, source } = parseGitUrl(starter);
+
+  if (protocols.length === 0) {
+    const repoInfo = parseShorthand(starter);
+    return {
+      ...repoInfo,
+      branch: await getDefaultBranch(repoInfo.fullName),
+      usedShorthand: true,
+    };
+  }
+
+  if (source !== 'github.com') {
+    stopProcess(`GitHub URL not found for: ${chalk.yellow(starter)}.`);
+  }
+
+  let branch;
+  if (ref) {
+    // Append the filepath to the parsed ref since a branch name could contain '/'
+    // If so, the rest of the branch name will be considered 'filepath' by 'parseGitUrl'
+    branch = filepath ? `${ref}/${filepath}` : ref;
+  } else {
+    branch = await getDefaultBranch(fullName);
+  }
+
+  return { name, fullName, branch };
+}
+
+/**
+ * @param {string} repoInfo GitHub repository information (full name, branch...).
+ * @param {string} tmpDir Path to the destination temporary directory.
+ */
+async function downloadGitHubRepo(repoInfo, tmpDir) {
+  const { fullName, branch, usedShorthand } = repoInfo;
+
+  const codeload = `https://codeload.github.com/${fullName}/tar.gz/${branch}`;
+  const response = await fetch(codeload);
+
+  if (!response.ok) {
+    const message = usedShorthand ? `using the shorthand` : `using the url`;
+    stopProcess(`Could not download the repository ${message}: ${chalk.yellow(fullName)}.`);
+  }
+
+  await new Promise(resolve => {
+    response.body.pipe(tar.extract({ strip: 1, cwd: tmpDir })).on('close', resolve);
+  });
+}
+
+module.exports = { getRepoInfo, downloadGitHubRepo };

package/utils/has-yarn.js

@@ -0,0 +1,14 @@
+'use strict';
+
+const execa = require('execa');
+
+module.exports = function hasYarn() {
+  try {
+    const { exitCode } = execa.sync('yarn --version', { shell: true });
+
+    if (exitCode === 0) return true;
+    return false;
+  } catch (err) {
+    return false;
+  }
+};

package/utils/logger.js

@@ -0,0 +1,17 @@
+'use strict';
+
+const chalk = require('chalk');
+
+module.exports = {
+  error(message) {
+    console.error(`${chalk.red('error')}: ${message}`);
+  },
+
+  warn(message) {
+    console.log(`${chalk.yellow('warning')}: ${message}`);
+  },
+
+  info(message) {
+    console.log(`${chalk.blue('info')}: ${message}`);
+  },
+};

package/utils/prompt-user.js

@@ -0,0 +1,103 @@
+'use strict';
+
+const inquirer = require('inquirer');
+const fetch = require('node-fetch');
+const yaml = require('js-yaml');
+
+/**
+ * @param {string|null} projectName - The name/path of project
+ * @param {string|null} starterUrl - The GitHub repo of the starter
+ * @returns Object containting prompt answers
+ */
+module.exports = async function promptUser(projectName, starter) {
+  const mainQuestions = [
+    {
+      type: 'input',
+      default: 'my-strapi-project',
+      name: 'directory',
+      message: 'What would you like to name your project?',
+      when: !projectName,
+    },
+    {
+      type: 'list',
+      name: 'quick',
+      message: 'Choose your installation type',
+      choices: [
+        {
+          name: 'Quickstart (recommended)',
+          value: true,
+        },
+        {
+          name: 'Custom (manual settings)',
+          value: false,
+        },
+      ],
+    },
+  ];
+
+  const [mainResponse, starterQuestion] = await Promise.all([
+    inquirer.prompt(mainQuestions),
+    getStarterQuestion(),
+  ]);
+
+  const starterResponse = await inquirer.prompt({
+    name: 'starter',
+    when: !starter,
+    ...starterQuestion,
+  });
+
+  return { ...mainResponse, ...starterResponse };
+};
+
+/**
+ *
+ * @returns Prompt question object
+ */
+async function getStarterQuestion() {
+  const content = await getStarterData();
+
+  // Fallback to manual input when fetch fails
+  if (!content) {
+    return {
+      type: 'input',
+      message: 'Please provide the GitHub URL for the starter you would like to use:',
+    };
+  }
+
+  const choices = content.map(option => {
+    const name = option.title.replace('Starter', '');
+
+    return {
+      name,
+      value: `https://github.com/${option.repo}`,
+    };
+  });
+
+  return {
+    type: 'list',
+    message:
+      'Which starter would you like to use? (Starters are fullstack Strapi applications designed for a specific use case)',
+    pageSize: choices.length,
+    choices,
+  };
+}
+
+/**
+ *
+ * @returns JSON starter data
+ */
+async function getStarterData() {
+  const response = await fetch(
+    `https://api.github.com/repos/strapi/community-content/contents/starters/starters.yml`
+  );
+
+  if (!response.ok) {
+    return null;
+  }
+
+  const { content } = await response.json();
+  const buff = Buffer.from(content, 'base64');
+  const stringified = buff.toString('utf-8');
+
+  return yaml.load(stringified);
+}

package/utils/stop-process.js

@@ -0,0 +1,7 @@
+'use strict';
+const logger = require('./logger');
+
+module.exports = function stopProcess(message) {
+  if (message) logger.error(message);
+  process.exit(1);
+};