create-astra 0.1.1

package/README.md

@@ -0,0 +1,120 @@
+# create-astra
+
+A CLI tool that scaffolds production-ready backend projects with everything wired up automatically. No more manually editing config files, no more copy-pasting boilerplate.
+
+```bash
+npx create-astra
+```
+
+---
+
+## The problem
+
+Every time you start a backend project you repeat the same steps. Install dependencies, write a tsconfig, connect Prisma to a database adapter, write a docker-compose, set up a CI pipeline. It works but it's tedious and easy to get wrong.
+
+create-astra does all of that in one command.
+
+---
+
+## What it sets up
+
+Depending on your selections, create-astra generates a fully wired project with:
+
+- Express app with a working entry point
+- TypeScript configured correctly for Node.js
+- Prisma with schema, config, adapter, and generated client
+- Docker Compose with a postgres service wired to your env vars
+- GitHub Actions CI pipeline that matches your stack
+- `.env` and `.env.example` with all required variables
+- `.gitignore` with sensible defaults
+- `package.json` with all scripts ready to use
+
+---
+
+## Usage
+
+```bash
+npx create-astra
+```
+
+Follow the interactive prompts:
+
+```
+What is your project name? my-app
+Select a language: Node.js
+Select a framework: Express (TypeScript)
+Select extra features: Prisma, Docker, CI/CD
+```
+
+Then:
+
+```bash
+cd my-app
+npm run dev
+```
+
+---
+
+## Generated scripts
+
+| Script | What it does |
+|---|---|
+| `npm run dev` | starts the dev server |
+| `npm run build` | compiles TypeScript |
+| `npm run start` | runs the compiled app |
+| `npm run db:generate` | generates the Prisma client |
+| `npm run db:migrate` | runs database migrations |
+| `npm run db:studio` | opens Prisma Studio |
+
+---
+
+## After setup
+
+If you selected Prisma, you need to:
+
+1. Set up a postgres database
+2. Update `DATABASE_URL` in your `.env` with real credentials
+3. Run `npm run db:migrate` to create your tables
+
+The Prisma client is already generated during setup so TypeScript types resolve immediately.
+
+---
+
+## Supported stacks
+
+| Language | Framework | Status |
+|---|---|---|
+| Node.js | Express (JavaScript) | available |
+| Node.js | Express (TypeScript) | available |
+
+
+Want to add support for a new language or framework? See [CONTRIBUTING.md](./CONTRIBUTING.md).
+
+---
+
+## Supported plugins
+
+| Plugin | What it adds |
+|---|---|
+| Prisma | schema, config, adapter, client, db scripts |
+| Docker | Dockerfile, docker-compose, .dockerignore |
+| CI/CD | GitHub Actions pipeline |
+
+Want to add a new plugin? See [CONTRIBUTING.md](./CONTRIBUTING.md).
+
+---
+
+## Local development
+
+```bash
+git clone https://github.com/your-username/create-astra
+cd create-astra
+npm install
+npm run dev
+```
+
+---
+
+## License
+
+MIT

package/dist/generator.js

@@ -0,0 +1,144 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateProject = generateProject;
+const clack = __importStar(require("@clack/prompts"));
+const path_1 = __importDefault(require("path"));
+const execa_1 = require("execa");
+const promises_1 = __importDefault(require("fs/promises"));
+const base_1 = require("./plugins/base");
+const prisma_1 = require("./plugins/prisma");
+const docker_1 = require("./plugins/docker");
+const ci_1 = require("./plugins/ci");
+const files_1 = require("./utils/files");
+const packages_1 = require("./utils/packages");
+const env_1 = require("./utils/env");
+async function generateProject(options) {
+    if (options.language === 'node') {
+        await generateNodeProject(options);
+    }
+    else {
+        clack.outro('This language is coming soon. Want to contribute? github.com/you/create-astra');
+        process.exit(0);
+    }
+}
+async function generateNodeProject(options) {
+    const { projectName, extras } = options;
+    const projectPath = path_1.default.join(process.cwd(), projectName);
+    const spinner = clack.spinner();
+    const plugins = [
+        ...(options.language === 'node' ? [(0, base_1.createBasePlugin)(options)] : []),
+        ...(extras.includes('prisma') ? [(0, prisma_1.createPrismaPlugin)(options)] : []),
+        ...(extras.includes('docker') ? [(0, docker_1.createDockerPlugin)(options)] : []),
+        ...(extras.includes('ci') ? [(0, ci_1.createCiPlugin)(options)] : []),
+    ];
+    const dependencies = plugins.flatMap(p => p.dependencies);
+    const devDependencies = plugins.flatMap(p => p.devDependencies);
+    const envVars = plugins.reduce((acc, p) => ({ ...acc, ...p.envVars }), {});
+    const packageScripts = plugins.reduce((acc, p) => ({ ...acc, ...p.packageScripts }), {});
+    const files = plugins.flatMap(p => p.files);
+    spinner.start('Initialising project...');
+    try {
+        await (0, files_1.createFolder)(projectPath);
+        await (0, execa_1.execa)('npm', ['init', '-y'], { cwd: projectPath });
+        spinner.stop('Project initialised!');
+    }
+    catch (err) {
+        spinner.stop('Failed.');
+        clack.log.error('Could not initialise project.');
+        console.error(err);
+        process.exit(1);
+    }
+    spinner.start('Creating files...');
+    try {
+        for (const file of files) {
+            await (0, files_1.createFile)(file.path, file.content);
+        }
+        await writeGitignore(projectPath);
+        spinner.stop('Files created!');
+    }
+    catch (err) {
+        spinner.stop('Failed.');
+        clack.log.error('Could not create files.');
+        console.error(err);
+        process.exit(1);
+    }
+    spinner.start('Writing environment variables...');
+    try {
+        await (0, env_1.writeEnvFile)(projectPath, envVars);
+        spinner.stop('Environment variables written!');
+    }
+    catch (err) {
+        spinner.stop('Failed.');
+        clack.log.error('Could not write env files.');
+        console.error(err);
+        process.exit(1);
+    }
+    spinner.start('Installing dependencies...');
+    try {
+        await (0, packages_1.installPackages)(dependencies, projectPath);
+        await (0, packages_1.installPackages)(devDependencies, projectPath, true);
+        spinner.stop('Dependencies installed!');
+    }
+    catch (err) {
+        spinner.stop('Failed.');
+        clack.log.error('Could not install dependencies.');
+        process.exit(1);
+    }
+    spinner.start('Configuring package.json...');
+    try {
+        await patchPackageJson(projectPath, packageScripts);
+        spinner.stop('package.json configured!');
+    }
+    catch (err) {
+        spinner.stop('Failed.');
+        clack.log.error('Could not configure package.json.');
+        process.exit(1);
+    }
+    clack.outro(`Your project is ready! cd ${projectName} and npm run dev to start.`);
+}
+async function writeGitignore(projectPath) {
+    await (0, files_1.createFile)(path_1.default.join(projectPath, '.gitignore'), `node_modules\ndist\n.env\ngenerated\n`);
+}
+async function patchPackageJson(projectPath, scripts) {
+    const packageJsonPath = path_1.default.join(projectPath, 'package.json');
+    const raw = await promises_1.default.readFile(packageJsonPath, 'utf-8');
+    const packageJson = JSON.parse(raw);
+    packageJson.scripts = { ...packageJson.scripts, ...scripts };
+    await promises_1.default.writeFile(packageJsonPath, JSON.stringify(packageJson, null, 2));
+}

package/dist/index.js

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const prompts_1 = require("./prompts");
+const generator_1 = require("./generator");
+async function main() {
+    const options = await (0, prompts_1.getProjectOptions)();
+    await (0, generator_1.generateProject)(options);
+}
+main().catch(err => {
+    console.error(err);
+    process.exit(1);
+});

package/dist/plugins/base/index.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createBasePlugin = void 0;
+const createBasePlugin = (options) => {
+    const { projectName, useTypescript } = options;
+    const ext = useTypescript ? 'ts' : 'js';
+    const srcEntry = useTypescript ?
+        `import express from 'express'
+
+const app = express()
+const PORT = process.env.PORT || 3000
+
+app.use(express.json())
+
+app.get('/', (req,res) => {
+res.json({message: 'Hello from ${projectName}'})
+})
+
+app.listen(PORT, () => {
+  console.log(\`Server running on port \${PORT}\`)
+})
+`
+        :
+            `const express = require('express')
+   const app = express()
+const PORT = process.env.PORT || 3000
+
+app.use(express.json())
+
+app.get('/', (req, res) => {
+  res.json({ message: 'Hello from ${projectName}!' })
+})
+
+app.listen(PORT, () => {
+  console.log(\`Server running on port \${PORT}\`)
+})
+  `;
+    return {
+        name: 'base',
+        dependencies: ['express'],
+        devDependencies: useTypescript
+            ? ['typescript', 'ts-node', '@types/node', '@types/express']
+            : [],
+        files: [
+            {
+                path: `${projectName}/src/index.${ext}`,
+                content: srcEntry
+            },
+            ...(useTypescript ? [{
+                    path: `${projectName}/tsconfig.json`,
+                    content: JSON.stringify({
+                        compilerOptions: {
+                            target: 'es2020',
+                            module: 'commonjs',
+                            rootDir: 'src',
+                            outDir: 'dist',
+                            strict: true,
+                            esModuleInterop: true,
+                            types: ['node']
+                        },
+                        include: ['src/**/*']
+                    }, null, 2)
+                }] : []),
+        ],
+        envVars: {
+            PORT: '3000',
+            NODE_ENV: 'development',
+        },
+        packageScripts: useTypescript ? {
+            dev: 'ts-node src/index.ts',
+            build: 'tsc',
+            start: 'node dist/index.js',
+        } : {
+            dev: 'node src/index.js',
+            start: 'node src/index.js',
+        }
+    };
+};
+exports.createBasePlugin = createBasePlugin;

package/dist/plugins/ci/index.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCiPlugin = createCiPlugin;
+function createCiPlugin(options) {
+    const { projectName, useTypescript, extras } = options;
+    const hasPrisma = extras.includes('prisma');
+    const ciContent = `name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    ${hasPrisma ? `services:
+      postgres:
+        image: postgres:15
+        env:
+          POSTGRES_USER: user
+          POSTGRES_PASSWORD: password
+          POSTGRES_DB: mydb
+        ports:
+          - 5432:5432
+        options: >-
+          --health-cmd pg_isready
+          --health-interval 10s
+          --health-timeout 5s
+          --health-retries 5` : ''}
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: 20
+          cache: 'npm'
+
+      - name: Install dependencies
+        run: npm install
+
+      ${hasPrisma ? `- name: Generate Prisma client
+        run: npm run db:generate
+        env:
+          DATABASE_URL: postgresql://user:password@localhost:5432/mydb` : ''}
+
+      ${useTypescript ? `- name: Build
+        run: npm run build` : ''}
+`;
+    return {
+        name: 'ci',
+        dependencies: [],
+        devDependencies: [],
+        files: [
+            {
+                path: `${projectName}/.github/workflows/ci.yml`,
+                content: ciContent,
+            },
+        ],
+        envVars: {},
+        packageScripts: {},
+    };
+}

package/dist/plugins/docker/index.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDockerPlugin = createDockerPlugin;
+function createDockerPlugin(options) {
+    const { projectName, extras } = options;
+    const hasPrisma = extras.includes('prisma');
+    const dockerComposeContent = `services:
+  app:
+    build: .
+    ports:
+      - "\${PORT}:3000"
+    env_file:
+      - .env
+    depends_on:
+      ${hasPrisma ? '- postgres' : ''}
+
+${hasPrisma ? `  postgres:
+    image: postgres:15
+    restart: always
+    environment:
+      POSTGRES_USER: user
+      POSTGRES_PASSWORD: password
+      POSTGRES_DB: mydb
+    ports:
+      - "5432:5432"
+    volumes:
+      - postgres_data:/var/lib/postgresql/data` : ''}
+
+${hasPrisma ? `volumes:
+  postgres_data:` : ''}
+`;
+    const dockerfileContent = `FROM node:20-alpine
+
+WORKDIR /app
+
+COPY package*.json ./
+RUN npm install
+
+COPY . .
+
+${options.useTypescript ? 'RUN npm run build\nCMD ["node", "dist/index.js"]' : 'CMD ["node", "src/index.js"]'}
+`;
+    const dockerignoreContent = `node_modules
+dist
+.env
+generated
+`;
+    return {
+        name: 'docker',
+        dependencies: [],
+        devDependencies: [],
+        files: [
+            {
+                path: `${projectName}/docker-compose.yml`,
+                content: dockerComposeContent,
+            },
+            {
+                path: `${projectName}/Dockerfile`,
+                content: dockerfileContent,
+            },
+            {
+                path: `${projectName}/.dockerignore`,
+                content: dockerignoreContent,
+            },
+        ],
+        envVars: {},
+        packageScripts: {},
+    };
+}

package/dist/plugins/prisma/index.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPrismaPlugin = void 0;
+const createPrismaPlugin = (options) => {
+    const { projectName, useTypescript } = options;
+    const prismaConfig = `prisma.config.ts`;
+    const schemaContent = `generator client {
+    provider = "prisma-client"
+    output   = "../generated/prisma"
+    }
+
+    datasource db {
+    provider = "postgresql"
+    }`;
+    const prismaConfigContent = `import path from 'path'
+  import { defineConfig } from 'prisma/config'
+
+  export default defineConfig({
+  earlyAccess: true,
+  schema: path.join('prisma', 'schema.prisma'),
+  migrate: {
+    async adapter() {
+      const { PrismaPg } = await import('@prisma/adapter-pg')
+      return new PrismaPg({ connectionString: process.env.DATABASE_URL })
+    }
+  }
+})`;
+    const prismaClientContent = useTypescript
+        ? `import { PrismaClient } from '../../generated/prisma'
+  import { PrismaPg } from '@prisma/adapter-pg'
+
+  const adapter = new PrismaPg({ connectionString: process.env.DATABASE_URL! })
+  const prisma = new PrismaClient({ adapter })
+
+  export default prisma`
+        : `const { PrismaClient } = require('../../generated/prisma')
+  const { PrismaPg } = require('@prisma/adapter-pg')
+
+  const adapter = new PrismaPg({ connectionString: process.env.DATABASE_URL })
+  const prisma = new PrismaClient({ adapter })
+
+  module.exports = prisma`;
+    return {
+        name: 'prisma',
+        dependencies: ['@prisma/client', '@prisma/adapter-pg', 'pg'],
+        devDependencies: ['prisma'],
+        files: [
+            {
+                path: `${projectName}/prisma/schema.prisma`,
+                content: schemaContent
+            },
+            {
+                path: `${projectName}/${prismaConfig}`,
+                content: prismaConfigContent
+            },
+            {
+                path: `${projectName}/src/lib/prisma.${useTypescript ? 'ts' : 'js'}`,
+                content: prismaClientContent
+            }
+        ],
+        envVars: {
+            DATABASE_URL: 'postgresql://user:password@localhost:5432/mydb'
+        },
+        packageScripts: {
+            'db:generate': 'prisma generate',
+            'db:migrate': 'prisma migrate dev',
+            'db:studio': 'prisma studio'
+        }
+    };
+};
+exports.createPrismaPlugin = createPrismaPlugin;

package/dist/plugins/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/prompts.js

@@ -0,0 +1,105 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getProjectOptions = void 0;
+const clack = __importStar(require("@clack/prompts"));
+const getProjectOptions = async () => {
+    clack.intro('Welcome to create-astra!');
+    const projectName = await clack.text({
+        message: 'What is your project name?',
+        placeholder: 'my-app',
+        validate(value) {
+            if (!value || value.trim() === '') {
+                return 'Project name cannot be empty.';
+            }
+        }
+    });
+    if (clack.isCancel(projectName)) {
+        clack.cancel('Operation cancelled.');
+        process.exit(0);
+    }
+    const language = await clack.select({
+        message: 'Select a language:',
+        options: [
+            { value: 'node', label: 'Js(node)' }
+        ]
+    });
+    if (clack.isCancel(language)) {
+        clack.cancel('Operation cancelled.');
+        process.exit(0);
+    }
+    const frameworkOptions = {
+        node: [
+            { value: 'express', label: 'Express (JavaScript)' },
+            { value: 'express-ts', label: 'Express (TypeScript)' },
+        ],
+        python: [
+            { value: 'fastapi', label: 'FastAPI' },
+            { value: 'flask', label: 'Flask' },
+        ],
+        go: [
+            { value: 'gin', label: 'Gin' },
+            { value: 'fiber', label: 'Fiber' },
+        ],
+    };
+    const framework = await clack.select({
+        message: 'Select a framework:',
+        options: frameworkOptions[language]
+    });
+    if (clack.isCancel(framework)) {
+        clack.cancel('Operation cancelled.');
+        process.exit(0);
+    }
+    const extras = await clack.multiselect({
+        message: 'Select extra features:',
+        options: [
+            { value: 'prisma', label: 'Prisma' },
+            { value: 'docker', label: 'Docker' },
+            { value: 'ci', label: 'CI/CD' },
+        ]
+    });
+    if (clack.isCancel(extras)) {
+        clack.cancel('Operation cancelled.');
+        process.exit(0);
+    }
+    return {
+        projectName: projectName,
+        language: language,
+        framework: framework,
+        extras: extras,
+        useTypescript: framework === 'express-ts'
+    };
+};
+exports.getProjectOptions = getProjectOptions;

package/dist/utils/env.js

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeEnvFile = void 0;
+const path_1 = __importDefault(require("path"));
+const files_1 = require("./files");
+const writeEnvFile = async (projectPath, vars) => {
+    const lines = Object.entries(vars)
+        .map(([key, value]) => `${key}=${value}`)
+        .join('\n');
+    await (0, files_1.createFile)(path_1.default.join(projectPath, '.env'), lines);
+    await (0, files_1.createFile)(path_1.default.join(projectPath, '.env.example'), Object.entries(vars)
+        .map(([key]) => `${key}=`)
+        .join('\n'));
+};
+exports.writeEnvFile = writeEnvFile;

package/dist/utils/files.js

@@ -0,0 +1,17 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createFolder = createFolder;
+exports.createFile = createFile;
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+async function createFolder(folderPath) {
+    await promises_1.default.mkdir(folderPath, { recursive: true });
+}
+async function createFile(filePath, content) {
+    const dir = path_1.default.dirname(filePath);
+    await promises_1.default.mkdir(dir, { recursive: true });
+    await promises_1.default.writeFile(filePath, content, 'utf-8');
+}

package/dist/utils/packages.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.installPackages = void 0;
+const execa_1 = require("execa");
+const installPackages = async (packages, projectPath, dev = false) => {
+    if (packages.length === 0)
+        return;
+    const flag = dev ? ['--save-dev'] : [];
+    await (0, execa_1.execa)('npm', ['install', ...flag, ...packages], { cwd: projectPath });
+};
+exports.installPackages = installPackages;

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "create-astra",
+  "version": "0.1.1",
+  "description": "A CLI that scaffolds production-ready backend projects",
+  "main": "dist/index.js",
+  "bin": {
+    "create-astra": "dist/index.js"
+  },
+  "scripts": {
+    "dev": "ts-node src/index.ts",
+    "build": "tsc",
+    "prepare": "npm run build"
+  },
+  "keywords": [
+    "cli",
+    "scaffold",
+    "express",
+    "prisma",
+    "typescript",
+    "backend"
+  ],
+  "author": "Njong Remy",
+  "license": "MIT",
+  "files": [
+    "dist"
+  ],
+  "type": "commonjs",
+  "dependencies": {
+    "@clack/prompts": "^1.6.0",
+    "execa": "^9.6.1"
+  },
+  "devDependencies": {
+    "@types/node": "^26.0.1",
+    "ts-node": "^10.9.2",
+    "typescript": "^6.0.3"
+  }
+}