tessl/npm-strapi--generate-new

Generate a new Strapi application with TypeScript/JavaScript support, database configuration, and template system.

—

Pending

Overview

Eval results

Files

Templates and Resources

Name: tessl/npm-strapi--generate-new
Author: tessl

Template processing and resource file management for project scaffolding, including support for custom templates, starter configurations, and comprehensive file generation for both TypeScript and JavaScript projects.

Capabilities

Template Configuration Interface

Configuration structure for custom templates and starters.

/**
 * Template configuration structure
 */
interface TemplateConfig {
  /** Package configuration overrides and additions */
  package: Record<string, unknown>;
}

/**
 * Package metadata information
 */
interface PackageInfo {
  /** Package name */
  name: string;
  /** Package version */
  version: string;
}

Template Merging

Core template merging functionality for integrating custom templates with generated projects.

/**
 * Merges custom template with generated project
 * Downloads and integrates template files, configurations, and dependencies
 * @param scope - Project configuration scope containing template URL/name
 * @param rootPath - Target project directory path
 * @throws Error if template installation fails
 */
function mergeTemplate(scope: Scope, rootPath: string): Promise<void>;

Supported Template Sources:

GitHub repositories (public and private with authentication)
npm packages containing Strapi templates
Local file system paths
Tarball URLs

Template Integration Features:

Automatic dependency merging
Configuration file overrides
Asset and resource copying
Template-specific setup scripts

NPM Template Fetching

Utility for downloading and processing npm-based templates.

/**
 * Fetches template from npm registry or URL
 * @param templateName - npm package name or URL
 * @param destination - Local directory to extract template
 * @returns Template metadata and configuration
 */
function fetchNpmTemplate(
  templateName: string,
  destination: string
): Promise<TemplateConfig>;

Resource Templates

Package.json Generation

Dynamic package.json generation with dependency management and project metadata.

/**
 * Generates package.json content for new Strapi project
 * @param options - Package generation options
 * @returns Complete package.json object
 */
function generatePackageJson(options: {
  /** Core Strapi dependencies to include */
  strapiDependencies: string[];
  /** Additional dependencies (React, etc.) */
  additionalsDependencies: Record<string, string>;
  /** Strapi version for dependency versions */
  strapiVersion: string;
  /** Project name (kebab-case) */
  projectName: string;
  /** Unique project identifier */
  uuid: string;
  /** Strapi-specific package.json configuration */
  packageJsonStrapi: Record<string, unknown>;
}): Record<string, unknown>;

Generated Package.json Features:

Automatic script configuration (develop, start, build, deploy)
Engine requirements (Node.js, npm versions)
Strapi-specific metadata
Development and production dependencies
License and repository information

TypeScript Configuration Templates

Configuration file generators for TypeScript projects.

/**
 * Generates tsconfig.json for admin panel
 * @returns TypeScript configuration object for admin
 */
function generateAdminTsConfig(): Record<string, unknown>;

/**
 * Generates tsconfig.json for server-side code
 * @returns TypeScript configuration object for server
 */
function generateServerTsConfig(): Record<string, unknown>;

TypeScript Configuration Features:

Optimized compiler options for Strapi development
Path mapping for module resolution
Strict type checking configuration
Build output configuration
Source map generation setup

JavaScript Configuration Templates

Configuration file generators for JavaScript projects.

/**
 * Generates jsconfig.json for JavaScript projects
 * @returns JavaScript project configuration object
 */
function generateJsConfig(): Record<string, unknown>;

Environment Configuration

Environment file and configuration generation.

/**
 * Creates .env file content with default environment variables
 * @returns Environment file content as string
 */
function createEnvFile(): string;

Generated Environment Variables:

# Server
HOST=0.0.0.0
PORT=1337

# Secrets
APP_KEYS=generated-keys
API_TOKEN_SALT=generated-salt
ADMIN_JWT_SECRET=generated-secret
TRANSFER_TOKEN_SALT=generated-salt

# Security
JWT_SECRET=generated-secret

File Templates and Resources

TypeScript Project Templates

Complete file templates for TypeScript Strapi projects.

Configuration Files:

config/admin.ts - Admin panel configuration
config/api.ts - API configuration
config/middlewares.ts - Middleware configuration
config/plugins.ts - Plugin configuration
config/server.ts - Server configuration

Application Files:

src/index.ts - Main application entry point
src/admin/webpack.config.example.js - Webpack configuration example

JavaScript Project Templates

Complete file templates for JavaScript Strapi projects.

Configuration Files:

config/admin.js - Admin panel configuration
config/api.js - API configuration
config/middlewares.js - Middleware configuration
config/plugins.js - Plugin configuration
config/server.js - Server configuration

Application Files:

src/index.js - Main application entry point
src/admin/webpack.config.example.js - Webpack configuration example

Dot Files and Configuration

Project configuration and tooling files.

Common Dot Files:

.gitignore - Git ignore patterns
.env.example - Environment variable template
.editorconfig - Editor configuration
.eslintrc.js - ESLint configuration
.prettierrc - Prettier configuration

JavaScript-Specific:

Additional JavaScript tooling configuration
JSDoc configuration
Babel configuration (if applicable)

Template Processing Workflow

Template Resolution

// Template source resolution
if (scope.template.startsWith('http')) {
  // URL-based template (GitHub, tarball, etc.)
  await downloadTemplate(scope.template, tempPath);
} else if (scope.template.includes('/')) {
  // npm scoped package
  await fetchNpmTemplate(scope.template, tempPath);
} else {
  // Simple npm package name
  await fetchNpmTemplate(scope.template, tempPath);
}

File Copying Strategy

// Language-specific file copying
const language = scope.useTypescript ? 'ts' : 'js';

// Copy base template files
await fse.copy(
  join(resourcesPath, 'files', language),
  scope.rootPath
);

// Copy common dot files
await copyDotFiles('common');

// Copy language-specific dot files
if (!scope.useTypescript) {
  await copyDotFiles('js');
}

Template Integration

// Merge template configuration
if (scope.template) {
  const templateConfig = await mergeTemplate(scope, scope.rootPath);
  
  // Merge dependencies
  Object.assign(configuration.dependencies, templateConfig.package.dependencies);
  
  // Apply configuration overrides
  applyTemplateOverrides(scope, templateConfig);
}

Usage Examples

Custom GitHub Template

import { generateNewApp } from "@strapi/generate-new";

await generateNewApp("./my-app", {
  template: "https://github.com/strapi/strapi-template-blog",
  typescript: true
});

NPM Template Package

await generateNewApp("./my-app", {
  template: "@strapi/template-corporate",
  starter: "blog"
});

Template with Custom Configuration

await generateNewApp("./my-app", {
  template: "https://github.com/user/custom-strapi-template",
  typescript: true,
  dbclient: "postgres",
  dbhost: "localhost"
});

Install with Tessl CLI

npx tessl i tessl/npm-strapi--generate-new

docs