@postxl/cli 1.0.12 → 1.1.0

package/dist/create-project/create-project.generator.js

@@ -38,44 +38,19 @@ const fs = __importStar(require("node:fs/promises"));
 const path = __importStar(require("node:path"));
 const Generator = __importStar(require("@postxl/generator"));
 const generator_1 = require("@postxl/generator");
-const baseDevDependencies = [
+const devDependencies = [
+    { packageName: Generator.toPostXlPackageName('@postxl/cli') },
     { packageName: Generator.toPostXlPackageName('@postxl/generator') },
     { packageName: Generator.toPostXlPackageName('@postxl/generators') },
     { packageName: Generator.toPostXlPackageName('@postxl/schema') },
-    { packageName: '@typescript-eslint/eslint-plugin', version: '8.46.3' },
-    { packageName: '@typescript-eslint/parser', version: '8.46.3' },
-    { packageName: 'commander', version: '12.1.0' },
+    { packageName: 'prettier', version: '3.7.4' },
+    { packageName: 'eslint', version: '9.39.2' },
 ];
-const workspaceDevDependencies = [
-    { packageName: '@prisma/client', version: '6.19.0' },
-    { packageName: 'chokidar-cli', version: '3.0.0' },
-    { packageName: 'eslint', version: '9.39.1' },
-    { packageName: 'eslint-plugin-simple-import-sort', version: '12.1.1' },
-    { packageName: 'jest', version: '29.7.0' },
-    { packageName: 'prettier', version: '3.4.2' },
-    { packageName: 'prisma', version: '6.19.0' },
-    { packageName: 'rimraf', version: '6.1.0' },
-];
-const baseScripts = [
-    { name: 'prettier:check', command: 'prettier --check "**/*.{ts,tsx}" --config ../../prettier.config.js' },
-    { name: 'pxl', command: 'node ../../packages/cli/dist/index.js' },
-];
-const getWorkspaceScripts = (slug) => [
-    { name: 'docker', command: './scripts/docker.sh' },
+const scripts = [
     { name: 'generate', command: 'pnpm run generate:project && pnpm run generate:prisma' },
+    { name: 'generate:project', command: 'pnpm run generate:project:pxl' },
+    { name: 'generate:project:pxl', command: 'pnpm pxl generate' },
     { name: 'generate:prisma', command: 'prisma generate' },
-    { name: 'generate:project', command: 'pnpm run generate:project:pxl && pnpm run generate:project:tsr' },
-    { name: 'generate:project:pxl', command: 'node ../../packages/cli/dist/index.js generate' },
-    { name: 'generate:project:tsr', command: `pnpm --filter @postxl/${slug}-frontend exec tsr generate` },
-    {
-        name: 'generate:watch',
-        command: "chokidar '../../packages/**/dist/**' '../../generators/**/dist/**' '../../generators/**/template/**' './generate.ts' './postxl-schema.json' -c 'pnpm run generate:project:pxl -f -i && pnpm run generate:project:tsr'",
-    },
-    { name: 'setup', command: './scripts/setup.sh' },
-];
-// TODO: Adjust this for standalone projects once full standalone generation is implemented!
-const standaloneScripts = [
-    { name: 'generate', command: 'node ../../packages/cli/dist/index.js generate' },
 ];
 const tsConfig = {
     compilerOptions: {
@@ -114,9 +89,9 @@ const generators = [
     'e2eGenerator',
     'frontendAdminGenerator',
     { imports: 'Frontend', code: 'Frontend.configureFrontendGenerator(Frontend.all)' },
-    'frontendFormsGenerator',
     'frontendTablesGenerator',
     'frontendTrpcClientGenerator',
+    'frontendFormsGenerator',
     'mockDataGenerator',
     'seedDataGenerator',
     'typesGenerator',
@@ -127,7 +102,7 @@ const generators = [
  */
 async function createProject(options) {
     const { projectPath, name, slug, schema } = options;
-    const targetPath = projectPath.kind === 'standalone' ? projectPath.workspaceProjectPath : projectPath.projectGenerationPath;
+    const targetPath = projectPath;
     // Create target directory if it doesn't exist
     await fs.mkdir(targetPath, { recursive: true });
     // Update schema with new name and slug
@@ -136,7 +111,7 @@ async function createProject(options) {
         ...schema,
         name,
         slug,
-        projectType: projectPath.kind,
+        projectType: 'standalone',
     };
     // Write source files directly to disk (not tracked as generated files)
     // These are the files that define the project, not generated output
@@ -148,14 +123,13 @@ async function createProject(options) {
         name: Generator.toPostXlPackageName(`@postxl/${slug}`),
         description: `A PostXL project for ${name}.`,
         dependencies: [],
-        devDependencies: [...baseDevDependencies, ...(projectPath.kind === 'workspace' ? workspaceDevDependencies : [])],
-        scripts: [...baseScripts, ...(projectPath.kind === 'workspace' ? getWorkspaceScripts(slug) : standaloneScripts)],
+        devDependencies,
+        scripts,
+        isInPostXlWorkspace: false,
+        packageManager: 'pnpm@10.26.1',
     };
     await fs.writeFile(path.join(targetPath, 'package.json'), await (0, generator_1.format)({ path: 'package.json', content: Generator.generatePackageJson(packageJsonConfig) }));
-    // Generate .env and .env.example with database connection and target generation path
-    const relativeGenerationPath = path.relative(targetPath, projectPath.projectGenerationPath) || '.';
-    const envContent = `DATABASE_CONNECTION=postgresql://postgres:postgres@localhost:5432/${slug}\n` +
-        `PXL_PROJECT_PATH=${relativeGenerationPath}\n`;
+    const envContent = `DATABASE_CONNECTION=postgresql://postgres:postgres@localhost:5432/${slug}`;
     await fs.writeFile(path.join(targetPath, '.env.example'), envContent);
     await fs.writeFile(path.join(targetPath, '.env'), envContent);
 }

package/dist/create-project.command.d.ts

@@ -1,13 +1,3 @@
 import { Command } from 'commander';
 export declare function register(program: Command): void;
-export type ProjectPath = ProjectPath_Standalone | ProjectPath_Workspace;
-type ProjectPath_Standalone = {
-    kind: 'standalone';
-    workspaceProjectPath: string;
-    projectGenerationPath: string;
-};
-type ProjectPath_Workspace = {
-    kind: 'workspace';
-    projectGenerationPath: string;
-};
-export {};
+export type ProjectPath = string;

package/dist/create-project.command.js

@@ -43,6 +43,15 @@ const schema_1 = require("@postxl/schema");
 const utils_1 = require("@postxl/utils");
 const create_project_generator_1 = require("./create-project/create-project.generator");
 const execAsync = (0, node_util_1.promisify)(node_child_process_1.exec);
+async function run(command, options) {
+    const { stdout, stderr } = await execAsync(command, options);
+    if (stdout) {
+        console.log(stdout);
+    }
+    if (stderr) {
+        console.error(stderr);
+    }
+}
 function register(program) {
     program
         .command('create-project')
@@ -51,12 +60,14 @@ function register(program) {
         .description('Creates a new PostXL project with the simple schema template.')
         .option('-n, --name <name>', 'Project name')
         .option('-s, --slug <slug>', 'Project slug')
-        .option('-p, --project-path <path>', 'Path where the generated project should be written. If not specified, a workspace project will be created in the projects folder')
+        .option('-p, --project-path <path>', 'Path where the generated project should be written. If not specified, user will be prompted')
         .option('--skip-git', 'Skip initialing a git repository in the generated project directory')
         .option('--skip-generate', 'Skip running the initial project generation')
+        .option('-l, --link-postxl', 'Link project to local PostXL monorepo packages (for development purposes)')
         .action(async (options) => {
         try {
             await checkNodeVersion();
+            const link = options.linkPostxl === true;
             const name = await getProjectName(options.name);
             const slug = await getProjectSlug(options.slug, name);
             const schema = getProjectSchema();
@@ -68,18 +79,24 @@ function register(program) {
                 projectPath,
             });
             // In case it is a workspace project, we install dependencies in the workspace part - else in the project
-            await installDependencies(projectPath.kind === 'workspace' ? projectPath.projectGenerationPath : projectPath.workspaceProjectPath);
+            await installDependencies({ targetPath: projectPath, link });
             if (!options.skipGenerate) {
-                await runGenerate(projectPath);
-                await installDependencies(projectPath.projectGenerationPath);
-                await generatePrismaClient(projectPath.projectGenerationPath);
-                if (!options.skipInitGit && projectPath.kind === 'standalone') {
-                    await initializeGitRepository(projectPath.projectGenerationPath);
+                // We initially only install the PostXL generator - without prettier, eslint and eslint rules. Hence, we run the first generation
+                // without transformations. This generates the full package.json with all scripts and dependencies.
+                await runGenerate({ projectPath, transform: false });
+                // After the generation, we now have the full package.json including devDependencies for prettier, eslint, etc.
+                // So we install dependencies again to get those.
+                await installDependencies({ targetPath: projectPath, link });
+                // The second generation runs with transformations - setting up prettier, eslint, etc.
+                await runGenerate({ projectPath, transform: true });
+                await generatePrismaClient(projectPath);
+                if (!options.skipInitGit) {
+                    await initializeGitRepository(projectPath);
                 }
             }
-            console.log(`\n✓ Project "${name}" created successfully at ${projectPath.projectGenerationPath}`);
+            console.log(`\n✓ Project "${name}" created successfully at ${projectPath}`);
             console.log('\nNext steps:');
-            console.log(`  cd ${path.relative(process.cwd(), projectPath.projectGenerationPath)}`);
+            console.log(`  cd ${path.relative(process.cwd(), projectPath)}`);
             console.log('  pnpm run generate  # generates the project to your configured path');
             console.log('  pnpm run dev  # in backend/');
             console.log('  pnpm run dev  # in frontend/');
@@ -117,53 +134,30 @@ function getProjectSchema() {
     return schema_1.sampleSchemas.simple;
 }
 /**
- * If projectPath is provided:
- *   - if it is local within projects, check if it exists, if yes, throw error. if not, create it and return workspace project
- *   - if it is outside of the cwd (regardless of local or absolute), check if exists. if so, throw error, if not create and return standalone project
  * If projectPath is not provided:
- *   - Ask user if it should be standalone (in ../{slug}) or workspace (in ./projects/{slug}). Default is standalone.
- *    - Create the folder and return the appropriate project path
+ *   - Prompt user for path if it should be standalone (in ../{slug}) or workspace (in ./projects/{slug}). Default is standalone.
+ * With projectPath:
+ *   - if it is local within projects, throw error as we do not support workspace project anymore.
+ *   - if it is outside of the cwd (regardless of local or absolute), check if exists. if so, throw error, if not create and return-
  */
 async function resolveProjectPath({ slug, projectPath, }) {
     const repositoryRoot = process.cwd();
-    const projectsFolder = path.join(repositoryRoot, 'projects');
     const defaultStandalonePath = path.resolve(repositoryRoot, '..', slug);
-    const workspaceProjectPath = path.join(projectsFolder, slug);
-    if (projectPath) {
-        const projectGenerationPath = path.isAbsolute(projectPath) ? projectPath : path.resolve(process.cwd(), projectPath);
-        await createFolderOrThrow(projectGenerationPath);
-        const isInProjectsFolder = projectGenerationPath.startsWith(projectsFolder + path.sep);
-        if (isInProjectsFolder) {
-            return { kind: 'workspace', projectGenerationPath };
-        }
-        else {
-            await createFolderOrThrow(workspaceProjectPath);
-            return {
-                kind: 'standalone',
-                workspaceProjectPath,
-                projectGenerationPath,
-            };
-        }
+    if (!projectPath) {
+        projectPath = await prompt('Project path', defaultStandalonePath);
     }
-    // No projectPath provided, ask user
-    const selectedOption = await select('Where should the project be created?', [`Standalone project at ${defaultStandalonePath}`, `Workspace project at ${workspaceProjectPath}`], 0);
-    const useWorkspace = selectedOption === 1;
-    if (useWorkspace) {
-        await createFolderOrThrow(workspaceProjectPath);
-        return {
-            kind: 'workspace',
-            projectGenerationPath: workspaceProjectPath,
-        };
+    if (!projectPath) {
+        console.error('Project path is required!');
+        process.exit(1);
     }
-    else {
-        await createFolderOrThrow(workspaceProjectPath);
-        await createFolderOrThrow(defaultStandalonePath);
-        return {
-            kind: 'standalone',
-            workspaceProjectPath,
-            projectGenerationPath: defaultStandalonePath,
-        };
+    const projectGenerationPath = path.isAbsolute(projectPath) ? projectPath : path.resolve(repositoryRoot, projectPath);
+    const projectsFolder = path.join(repositoryRoot, 'projects');
+    const isInProjectsFolder = projectGenerationPath.startsWith(projectsFolder + path.sep);
+    if (isInProjectsFolder) {
+        throw new Error('Creating workspace projects is no longer supported. Please provide a different path outside of the "postxl" repo folder!');
     }
+    await createFolderOrThrow(projectGenerationPath);
+    return projectGenerationPath;
 }
 async function createFolderOrThrow(targetPath) {
     try {
@@ -177,7 +171,7 @@ async function createFolderOrThrow(targetPath) {
     }
 }
 async function createProjectStructure({ name, slug, schema, projectPath, }) {
-    console.log(`\nCreating project "${name}" at ${projectPath.projectGenerationPath}...`);
+    console.log(`\nCreating project "${name}" at ${projectPath}...`);
     await (0, create_project_generator_1.createProject)({
         name: (0, schema_1.toProjectSchemaName)(name),
         slug: (0, schema_1.toProjectSlug)(slug),
@@ -186,16 +180,13 @@ async function createProjectStructure({ name, slug, schema, projectPath, }) {
     });
     console.log('Project files created successfully!');
 }
-async function installDependencies(path) {
+async function installDependencies({ targetPath, link }) {
     console.log('\nInstalling dependencies...');
     try {
-        const { stdout, stderr } = await execAsync('pnpm install', { cwd: path });
-        if (stdout) {
-            console.log(stdout);
-        }
-        if (stderr) {
-            console.error(stderr);
+        if (link) {
+            await linkPostXlPackages(targetPath);
         }
+        await run('pnpm install', { cwd: targetPath });
         console.log('Dependencies installed successfully!');
     }
     catch (error) {
@@ -203,20 +194,94 @@ async function installDependencies(path) {
         console.log('You can manually run "pnpm install" in the project directory.');
     }
 }
-async function runGenerate(projectPath) {
-    console.log('\nGenerating project code...');
+async function fileExists(filePath) {
+    return fs
+        .access(filePath)
+        .then(() => true)
+        .catch(() => false);
+}
+async function readPackageJson(packageJsonPath) {
+    if (!(await fileExists(packageJsonPath))) {
+        return null;
+    }
+    const content = await fs.readFile(packageJsonPath, 'utf-8');
+    return JSON.parse(content);
+}
+function extractPostXlPackages(packageJson) {
+    const filterPostXl = (deps) => Object.keys(deps ?? {}).filter((pkg) => pkg.startsWith('@postxl/'));
+    return {
+        deps: filterPostXl(packageJson.dependencies),
+        devDeps: filterPostXl(packageJson.devDependencies),
+    };
+}
+function toLocalPackagePaths(packages, relativePathToMonorepo) {
+    return packages.map((pkg) => {
+        const packageName = pkg.replace('@postxl/', '');
+        return path.join(relativePathToMonorepo, 'packages', packageName);
+    });
+}
+async function linkPackagesInDir(dir, packages, relativePathToMonorepo, workspaceFlag) {
+    const { deps, devDeps } = packages;
+    if (deps.length === 0 && devDeps.length === 0) {
+        return;
+    }
+    console.log(`  Linking in ${dir}...`);
+    // Link regular dependencies
+    if (deps.length > 0) {
+        const localPaths = toLocalPackagePaths(deps, relativePathToMonorepo);
+        await run(`pnpm add ${localPaths.join(' ')}${workspaceFlag}`, { cwd: dir });
+    }
+    // Link devDependencies
+    if (devDeps.length > 0) {
+        const localPaths = toLocalPackagePaths(devDeps, relativePathToMonorepo);
+        await run(`pnpm add -D ${localPaths.join(' ')}${workspaceFlag}`, { cwd: dir });
+    }
+}
+async function linkPostXlPackages(targetPath) {
+    console.log('\nLinking PostXL packages...');
     try {
-        const path = projectPath.kind === 'standalone' ? projectPath.workspaceProjectPath : projectPath.projectGenerationPath;
-        const { stdout, stderr } = await execAsync('pnpm run generate:project -f', {
-            cwd: path,
-            env: { ...process.env, PXL_PROJECT_PATH: projectPath.projectGenerationPath },
-        });
-        if (stdout) {
-            console.log(stdout);
+        const isWorkspace = await fileExists(path.join(targetPath, 'pnpm-workspace.yaml'));
+        const workspaceFlag = isWorkspace ? ' -w' : '';
+        const packageJsonPaths = [
+            { dir: targetPath, packageJson: path.join(targetPath, 'package.json') },
+            { dir: path.join(targetPath, 'frontend'), packageJson: path.join(targetPath, 'frontend', 'package.json') },
+            { dir: path.join(targetPath, 'backend'), packageJson: path.join(targetPath, 'backend', 'package.json') },
+        ];
+        let totalLinked = 0;
+        for (const { dir, packageJson: packageJsonPath } of packageJsonPaths) {
+            const packageJson = await readPackageJson(packageJsonPath);
+            if (!packageJson) {
+                continue;
+            }
+            const packages = extractPostXlPackages(packageJson);
+            const count = packages.deps.length + packages.devDeps.length;
+            if (count === 0) {
+                continue;
+            }
+            totalLinked += count;
+            const relPath = path.relative(dir, process.cwd()).replaceAll('\\', '/');
+            // For subdirs (frontend/backend), don't use workspace flag
+            const flag = dir === targetPath ? workspaceFlag : '';
+            await linkPackagesInDir(dir, packages, relPath, flag);
         }
-        if (stderr) {
-            console.error(stderr);
+        if (totalLinked === 0) {
+            console.log('No @postxl/* packages found.');
+            return;
         }
+        console.log('PostXL packages linked successfully!');
+    }
+    catch (error) {
+        console.error('Failed to link PostXL packages:', error);
+        console.log('You can manually run the linking commands in the project directory.');
+    }
+}
+async function runGenerate({ projectPath, transform, }) {
+    console.log('\nGenerating project code...');
+    try {
+        await run(`pnpm run generate:project:pxl -f${transform ? '' : ' -t'}`, {
+            cwd: projectPath,
+            env: { ...process.env, PXL_PROJECT_PATH: projectPath },
+        });
         console.log('Project code generated successfully!');
     }
     catch (error) {
@@ -224,17 +289,10 @@ async function runGenerate(projectPath) {
         console.log('You can manually run "pnpm run generate" in the project directory.');
     }
 }
-async function generatePrismaClient(path) {
-    // 9. Generate Prisma
+async function generatePrismaClient(targetPath) {
     console.log('\nGenerating Prisma client...');
     try {
-        const { stdout, stderr } = await execAsync('pnpm run generate:prisma', { cwd: path });
-        if (stdout) {
-            console.log(stdout);
-        }
-        if (stderr) {
-            console.error(stderr);
-        }
+        await run('pnpm run generate:prisma', { cwd: targetPath });
         console.log('Prisma client generated successfully!');
     }
     catch (error) {
@@ -242,10 +300,10 @@ async function generatePrismaClient(path) {
         console.log('You can manually run "pnpm run generate:prisma" in the project directory.');
     }
 }
-async function initializeGitRepository(path) {
+async function initializeGitRepository(targetPath) {
     console.log('\nInitializing git repository...');
     try {
-        await execAsync('git init -b main', { cwd: path });
+        await run('git init -b main', { cwd: targetPath });
         console.log('Git repository initialized successfully!');
     }
     catch (error) {
@@ -293,41 +351,3 @@ async function prompt(question, defaultValue) {
         });
     });
 }
-// Helper to select from a list
-async function select(question, choices, defaultIndex = 0) {
-    if (choices.length === 0) {
-        throw new Error('No choices available');
-    }
-    if (defaultIndex < 0 || defaultIndex >= choices.length) {
-        defaultIndex = 0;
-    }
-    console.log(`\n${question}`);
-    for (const [index, choice] of choices.entries()) {
-        const num = index + 1;
-        const marker = index === defaultIndex ? ' (default)' : '';
-        console.log(`  ${num}. ${choice}${marker}`);
-    }
-    const rl = readline.createInterface({
-        input: process.stdin,
-        output: process.stdout,
-    });
-    return new Promise((resolve) => {
-        const promptText = `\nEnter your choice (number) [default ${defaultIndex + 1}]: `;
-        rl.question(promptText, (answer) => {
-            rl.close();
-            const trimmed = answer.trim();
-            if (!trimmed) {
-                resolve(defaultIndex);
-                return;
-            }
-            const index = Number.parseInt(trimmed, 10) - 1;
-            if (index >= 0 && index < choices.length) {
-                resolve(index);
-            }
-            else {
-                console.log('Invalid choice, using default option.');
-                resolve(defaultIndex);
-            }
-        });
-    });
-}

package/dist/generate.command.js

@@ -64,6 +64,7 @@ This reads the schema from ${(0, utils_1.yellow)('schema.json')} and runs the ge
         .option('-p, --pattern <glob>', 'filters files by glob pattern (e.g., "**/*.ts" or "backend/libs/**")')
         .option('-q, --quiet', 'does not print errors')
         .option('-s, --skip-lint', 'skips linting')
+        .option('-t, --skip-transform', 'skips linting and formatting')
         .option('-v, --verbose', 'shows verbose linting messages')
         .action(async (projectPath, targetPath, options) => {
         if (projectPath.startsWith('.')) {
@@ -104,20 +105,22 @@ This reads the schema from ${(0, utils_1.yellow)('schema.json')} and runs the ge
             .generate((g) => g)
             //
             .then(async (g) => {
-            const lintResult = await (0, generator_1.lint)(g.context.vfs, options);
-            if (!options.quiet) {
-                (0, generator_1.logLintResults)(lintResult, options);
+            if (!options.skipTransform) {
+                const lintResult = await (0, generator_1.lint)(g.context.vfs, options);
+                if (!options.quiet) {
+                    (0, generator_1.logLintResults)(lintResult, options);
+                }
+                await g.context.vfs.transform(generator_1.format, {
+                    onError: ({ path, error }) => {
+                        if (options.ignoreErrors) {
+                            console.error(`Error formatting ${path}:`, error);
+                        }
+                        else {
+                            throw error;
+                        }
+                    },
+                });
             }
-            await g.context.vfs.transform(generator_1.format, {
-                onError: ({ path, error }) => {
-                    if (options.ignoreErrors) {
-                        console.error(`Error formatting ${path}:`, error);
-                    }
-                    else {
-                        throw error;
-                    }
-                },
-            });
             const result = await (0, generator_1.sync)({
                 vfs: g.context.vfs,
                 lockFilePath: path.join(targetPath, 'postxl-lock.json'),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@postxl/cli",
-  "version": "1.0.12",
+  "version": "1.1.0",
   "description": "Command-line interface for PostXL code generation framework",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
@@ -44,8 +44,8 @@
     "commander": "14.0.2",
     "dotenv": "17.2.3",
     "zod-validation-error": "3.4.0",
-    "@postxl/generator": "^1.0.7",
-    "@postxl/generators": "^1.0.13",
+    "@postxl/generator": "^1.0.9",
+    "@postxl/generators": "^1.2.1",
     "@postxl/schema": "^1.0.3",
     "@postxl/utils": "^1.0.1"
   },