@anthonylzq/simba.js 9.0.0 → 9.1.0

package/lib/src/functions/tsconfig.js

@@ -1,120 +1,19 @@
 const writeFile = require('../utils/writeFile')
+const { renderTemplate } = require('../utils/renderTemplate')
 
 /**
- * @param {String} projectName
+ * @param {Object} args
+ * @param {String} args.projectName
+ * @param {Boolean} args.graphQL
  * @returns {Promise<void>}
  */
-module.exports = async projectName => {
-  const data = {
-    base: {
-      content: `{
-  "ts-node": {
-    "files": true,
-    "require": ["tsconfig-paths/register"]
-  },
-  "compilerOptions": {
-    /* Visit https://aka.ms/tsconfig.json to read more about this file */
-
-    /* Basic Options */
-    // "incremental": true,                   /* Enable incremental compilation */
-    "target": "ES2022"                        /* Specify ECMAScript target version: 'ES3' (default), 'ES5', 'ES2015', 'ES2016', 'ES2017', 'ES2018', 'ES2019', 'ES2020', 'ES2022', or 'ESNEXT'. */,
-    "module": "commonjs"                      /* Specify module code generation: 'none', 'commonjs', 'amd', 'system', 'umd', 'es2015', 'es2020', 'ES2022', or 'ESNext'. */,
-    "lib": ["es2022", "esnext.asynciterable"], /* Specify library files to be included in the compilation. */
-    "allowJs": true                           /* Allow javascript files to be compiled. */,
-    // "checkJs": true,                       /* Report errors in .js files. */
-    // "jsx": "preserve",                     /* Specify JSX code generation: 'preserve', 'react-native', or 'react'. */
-    // "declaration": true,                   /* Generates corresponding '.d.ts' file. */
-    // "declarationMap": true,                /* Generates a sourcemap for each corresponding '.d.ts' file. */
-    // "outFile": "./",                       /* Concatenate and emit output to single file. */
-    "outDir": "dist"                          /* Redirect output structure to the directory. */,
-    "rootDir": "src"                          /* Specify the root directory of input files. Use to control the output directory structure with --outDir. */,
-    // "composite": true,                     /* Enable project compilation */
-    // "tsBuildInfoFile": "./",               /* Specify file to store incremental compilation information */
-    // "removeComments": true,                /* Do not emit comments to output. */
-    // "noEmit": true,                        /* Do not emit outputs. */
-    // "importHelpers": true,                 /* Import emit helpers from 'tslib'. */
-    "downlevelIteration": true,               /* Provide full support for iterables in 'for-of', spread, and destructuring when targeting 'ES5' or 'ES3'. */
-    // "isolatedModules": true,               /* Transpile each file as a separate module (similar to 'ts.transpileModule'). */
-
-    /* Strict Type-Checking Options */
-    "strict": true                            /* Enable all strict type-checking options. */,
-    "noImplicitAny": true                     /* Raise error on expressions and declarations with an implied 'any' type. */,
-    "strictNullChecks": true,                 /* Enable strict null checks. */
-    "strictFunctionTypes": true,              /* Enable strict checking of function types. */
-    "strictBindCallApply": true,              /* Enable strict 'bind', 'call', and 'apply' methods on functions. */
-    "strictPropertyInitialization": true,    /* Enable strict checking of property initialization in classes. */
-    "noImplicitThis": true,                   /* Raise error on 'this' expressions with an implied 'any' type. */
-    "alwaysStrict": true,                     /* Parse in strict mode and emit "use strict" for each source file. */
-
-    /* Additional Checks */
-    "noUnusedLocals": true,                   /* Report errors on unused locals. */
-    "noUnusedParameters": true,               /* Report errors on unused parameters. */
-    "noImplicitReturns": true,                /* Report error when not all code paths in function return a value. */
-    "noFallthroughCasesInSwitch": true,       /* Report errors for fallthrough cases in switch statement. */
-
-    /* Module Resolution Options */
-    "moduleResolution": "node"                /* Specify module resolution strategy: 'node', 'classic', or 'bundler' (modern). */,
-    "baseUrl": "src",                         /* Base directory to resolve non-absolute module names. */
-    // "paths": {},                           /* A series of entries which re-map imports to lookup locations relative to the 'baseUrl'. */
-    // "rootDirs": [],                        /* List of root folders whose combined content represents the structure of the project at runtime. */
-    // "typeRoots": [],                       /* List of folders to include type definitions from. */
-    // "types": [],                           /* Type declaration files to be included in compilation. */
-    "allowSyntheticDefaultImports": true,     /* Allow default imports from modules with no default export. This does not affect code emit, just typechecking. */
-    "esModuleInterop": true                   /* Enables emit interoperability between CommonJS and ES Modules via creation of namespace objects for all imports. Implies 'allowSyntheticDefaultImports'. */,
-    // "preserveSymlinks": true,              /* Do not resolve the real path of symlinks. */
-    // "allowUmdGlobalAccess": true,          /* Allow accessing UMD globals from modules. */
-    "resolveJsonModule": true                 /* Allow import .json files */,
-
-    /* Source Map Options */
-    "sourceMap": false                        /* Generates corresponding '.map' file. */,
-    // "sourceRoot": "",                      /* Specify the location where debugger should locate TypeScript files instead of source locations. */
-    // "mapRoot": "",                         /* Specify the location where debugger should locate map files instead of generated locations. */
-    // "inlineSourceMap": true,               /* Emit a single file with source maps instead of having a separate file. */
-    // "inlineSources": true,                 /* Emit the source alongside the sourcemaps within a single file; requires '--inlineSourceMap' or '--sourceMap' to be set. */
-
-    /* Experimental Options */
-    "experimentalDecorators": true,           /* Enables experimental support for ES7 decorators. */
-    "emitDecoratorMetadata": true,            /* Enables experimental support for emitting type metadata for decorators. */
-
-    /* Advanced Options */
-    "skipLibCheck": true                      /* Skip type checking of declaration files. */,
-    "forceConsistentCasingInFileNames": true  /* Disallow inconsistently-cased references to the same file. */
-  },
-  "include": [
-    "src",
-    "test",
-    "tests",
-    "__test__"
-  ],
-  "exclude": [
-    "node_modules"
-  ]
-}
-`,
-      file: 'tsconfig.base.json'
-    },
-    prod: {
-      content: `{
-  "compilerOptions": {
-    "rootDir": "src"
-  },
-  "extends": "./tsconfig.base.json",
-  "exclude": [
-    "node_modules",
-    "test",
-    "tests",
-    "__test__",
-    "dist"
-  ],
-  "include": [
-    "src"
-  ]
-}
-`,
-      file: 'tsconfig.json'
-    }
-  }
-
-  await writeFile(`${projectName}/${data.base.file}`, data.base.content)
-  await writeFile(`${projectName}/${data.prod.file}`, data.prod.content)
+module.exports = async ({ projectName, graphQL = false }) => {
+  await writeFile(
+    `${projectName}/tsconfig.base.json`,
+    renderTemplate('config/tsconfig.base.json.ejs', { graphQL })
+  )
+  await writeFile(
+    `${projectName}/tsconfig.json`,
+    renderTemplate('config/tsconfig.json.ejs')
+  )
 }

package/lib/src/index.js

@@ -1,7 +1,8 @@
 const cliProgress = require('cli-progress')
-const colors = require('colors')
+const pc = require('picocolors')
 const util = require('node:util')
 const exec = util.promisify(require('node:child_process').exec)
+const mkdirs = require('./utils/mkdirs')
 
 const {
   packageJson,
@@ -14,7 +15,7 @@ const {
   docker,
   api,
   testsF,
-  ghatF
+  ghat: ghatF
 } = require('./functions')
 
 /**
@@ -22,13 +23,13 @@ const {
  * @returns {CliOptions}
  */
 const setOptions = process => {
-  const format = `${colors.bold(
+  const format = `${pc.bold(
     'Packages installation progress'
-  )} ${colors.cyan('[{bar}]')} ${colors.blue('{percentage}%')} | ${colors.bold(
+  )} ${pc.cyan('[{bar}]')} ${pc.blue('{percentage}%')} | ${pc.bold(
     'Current process:'
-  )} ${colors.yellow('{value}')} of ${process} | ${colors.bold(
+  )} ${pc.yellow('{value}')} of ${process} | ${pc.bold(
     'Duration:'
-  )} ${colors.green('{duration_formatted}')}`
+  )} ${pc.green('{duration_formatted}')}`
 
   return { format, hideCursor: false, synchronousUpdate: false }
 }
@@ -47,9 +48,11 @@ module.exports = async ({
   manager,
   mainFile,
   fastify,
+  hono,
   graphql,
   ghat,
-  database
+  database,
+  entityContext
 }) => {
   const process = 5
   let i = 0
@@ -58,15 +61,27 @@ module.exports = async ({
     options,
     cliProgress.Presets.shades_classic
   )
-  const expressProdPackages = 'express swagger-ui-express cors'
+  const expressProdPackages =
+    'express swagger-ui-express @asteasolutions/zod-to-openapi cors'
   const fastifyProdPackages = `fastify @fastify/swagger @fastify/swagger-ui @fastify/cors fastify-type-provider-zod ${
     graphql ? '@as-integrations/fastify' : ''
   }`
+  const honoProdPackages =
+    'hono @hono/node-server @hono/zod-openapi @hono/swagger-ui'
+
+  const frameworkProdPackages = hono
+    ? honoProdPackages
+    : fastify
+      ? fastifyProdPackages
+      : expressProdPackages
+
   let prodPackages = `${manager} debug zod http-errors @prisma/client@6 ${
     graphql
-      ? `@apollo/server ${!fastify ? '@as-integrations/express5' : ''} class-validator graphql graphql-scalars reflect-metadata type-graphql@2.0.0-rc.3`
+      ? `@apollo/server ${
+          !fastify && !hono ? '@as-integrations/express5' : ''
+        } class-validator graphql graphql-scalars reflect-metadata type-graphql@2.0.0-rc.3`
       : ''
-  } ${fastify ? fastifyProdPackages : expressProdPackages}`
+  } ${frameworkProdPackages}`
 
   switch (database) {
     case 'mongo':
@@ -97,26 +112,27 @@ module.exports = async ({
 axios \
 dotenv \
 nodemon \
-standard-version \
-ts-loader \
-ts-node \
-tsconfig-paths \
+commit-and-tag-version \
+tsx \
 typescript`
 
   const expressDevPackages =
     '@types/express @types/swagger-ui-express @types/cors'
   const fastifyDevPackages = ''
+  const honoDevPackages = ''
 
   devPackages += ` ${
-    fastify ? fastifyDevPackages : expressDevPackages
-  } @jest/types @types/jest jest jest-unit ts-jest`
+    hono ? honoDevPackages : fastify ? fastifyDevPackages : expressDevPackages
+  } vitest vite-tsconfig-paths`
+
+  if (graphql) devPackages += ' unplugin-swc @swc/core'
 
-  // Biome no necesita plugins adicionales de Jest como ESLint
+  // Biome no necesita plugins adicionales de Vitest como ESLint
 
   bar.start(process, i)
 
   try {
-    await exec(`mkdir ${projectName}`)
+    await mkdirs(projectName)
     bar.update(++i)
 
     const dbIsSQL = database !== 'mongo'
@@ -132,11 +148,19 @@ typescript`
       readme(projectName, projectDescription),
       changelog(projectName),
       gitignore(projectName),
-      tsconfig(projectName),
+      tsconfig({ projectName, graphQL: graphql }),
       biome({ projectName }),
       docker({ projectName, manager }),
-      api({ projectName, version, email, fastify, graphql, database }),
-      testsF({ projectName, graphql, dbIsSQL }),
+      api({
+        projectName,
+        email,
+        fastify,
+        hono,
+        graphql,
+        database,
+        entityContext
+      }),
+      testsF({ projectName, graphql, dbIsSQL, entityContext }),
       exec('git init', { cwd: `./${projectName}` })
     ]
 

package/lib/src/utils/entity.js

@@ -0,0 +1,115 @@
+const pluralize = require('pluralize')
+
+/**
+ * Build all naming variants for a given entity name.
+ *
+ * @param {string} raw PascalCase entity name (e.g. "Product", "User")
+ * @returns {EntityNames}
+ */
+const buildEntityNames = raw => {
+  // Ensure PascalCase
+  const pascal = raw.charAt(0).toUpperCase() + raw.slice(1)
+  const camel = pascal.charAt(0).toLowerCase() + pascal.slice(1)
+  const plural = pluralize(camel)
+  const pluralPascal = plural.charAt(0).toUpperCase() + plural.slice(1)
+
+  return { pascal, camel, plural, pluralPascal }
+}
+
+/**
+ * Build the field definitions for an entity.
+ * - Default "User" gets `name` + `lastName`
+ * - Any other entity gets `name` + `description`
+ *
+ * @param {string} entityPascal PascalCase entity name
+ * @returns {EntityFieldSet}
+ */
+const buildEntityFields = entityPascal => {
+  const isUser = entityPascal === 'User'
+
+  const fields = isUser
+    ? [
+        { name: 'lastName', prismaType: 'String', zodType: 'z.string()' },
+        { name: 'name', prismaType: 'String', zodType: 'z.string()' }
+      ]
+    : [
+        { name: 'name', prismaType: 'String', zodType: 'z.string()' },
+        {
+          name: 'description',
+          prismaType: 'String',
+          zodType: 'z.string()'
+        }
+      ]
+
+  const sampleData = isUser
+    ? { lastName: "'Lzq'", name: "'Anthony'" }
+    : { name: "'Test'", description: "'A test item'" }
+
+  const updateData = isUser
+    ? { lastName: "'Luzquiños'", name: "'Anthony'" }
+    : { name: "'Updated'", description: "'Updated description'" }
+
+  return { fields, sampleData, updateData, isUser }
+}
+
+/**
+ * Build the full entity context object to pass into EJS templates.
+ *
+ * @param {string} raw PascalCase entity name (default: "User")
+ * @returns {EntityContext}
+ */
+const buildEntityContext = (raw = 'User') => {
+  const names = buildEntityNames(raw)
+  const fieldSet = buildEntityFields(names.pascal)
+
+  return {
+    // Naming variants
+    Entity: names.pascal,
+    entity: names.camel,
+    entities: names.plural,
+    EntitiesPlural: names.pluralPascal,
+
+    // Fields
+    entityFields: fieldSet.fields,
+    sampleData: fieldSet.sampleData,
+    updateData: fieldSet.updateData,
+    isDefaultEntity: fieldSet.isUser
+  }
+}
+
+module.exports = { buildEntityNames, buildEntityFields, buildEntityContext }
+
+/**
+ * @typedef {Object} EntityNames
+ * @property {string} pascal  e.g. "Product"
+ * @property {string} camel   e.g. "product"
+ * @property {string} plural  e.g. "products"
+ * @property {string} pluralPascal e.g. "Products"
+ */
+
+/**
+ * @typedef {Object} EntityField
+ * @property {string} name
+ * @property {string} prismaType
+ * @property {string} zodType
+ */
+
+/**
+ * @typedef {Object} EntityFieldSet
+ * @property {EntityField[]} fields
+ * @property {Object<string,string>} sampleData
+ * @property {Object<string,string>} updateData
+ * @property {boolean} isUser
+ */
+
+/**
+ * @typedef {Object} EntityContext
+ * @property {string} Entity PascalCase name
+ * @property {string} entity camelCase name
+ * @property {string} entities plural lowercase name
+ * @property {string} EntitiesPlural plural PascalCase name
+ * @property {EntityField[]} entityFields field definitions
+ * @property {Object<string,string>} sampleData sample create data
+ * @property {Object<string,string>} updateData sample update data
+ * @property {boolean} isDefaultEntity true if entity is "User"
+ */

package/lib/src/utils/index.js

@@ -1,5 +1,7 @@
 module.exports = {
   constants: require('./constants'),
+  entity: require('./entity'),
+  renderTemplate: require('./renderTemplate').renderTemplate,
   titleCase: require('./titleCase'),
   writeFile: require('./writeFile')
 }

package/lib/src/utils/mkdirs.js

@@ -0,0 +1,9 @@
+const { mkdir } = require('node:fs/promises')
+
+/**
+ * Creates multiple directories recursively (cross-platform, no shell spawn).
+ * @param  {...String} dirs - Directory paths to create.
+ * @returns {Promise<void>}
+ */
+module.exports = (...dirs) =>
+  Promise.all(dirs.map(dir => mkdir(dir, { recursive: true })))

package/lib/src/utils/renderTemplate.js

@@ -0,0 +1,22 @@
+const { readFileSync } = require('node:fs')
+const { join } = require('node:path')
+const ejs = require('ejs')
+
+const TEMPLATES_DIR = join(__dirname, '..', '..', 'templates')
+
+/**
+ * Render an EJS template file with the given data.
+ * @param {string} templatePath - Relative path from the templates/ directory (e.g., 'api/services/BaseHttp.ts.ejs')
+ * @param {Record<string, unknown>} data - Variables to pass to the template
+ * @returns {string} The rendered template content
+ */
+const renderTemplate = (templatePath, data = {}) => {
+  const fullPath = join(TEMPLATES_DIR, templatePath)
+  const template = readFileSync(fullPath, 'utf-8')
+
+  return ejs.render(template, data, {
+    filename: fullPath
+  })
+}
+
+module.exports = { renderTemplate, TEMPLATES_DIR }

package/lib/src/utils/titleCase.js

@@ -3,14 +3,9 @@
  * @returns {String}
  */
 module.exports = projectName => {
-  const pn = projectName.toLowerCase().split('-')
-  let title = ''
-
-  pn.forEach((word, index, array) => {
-    title += `${word[0].toUpperCase()}${word.slice(1)} `
-
-    if (index !== array.length - 1) title += ' '
-  })
-
-  return title.trim()
+  return projectName
+    .toLowerCase()
+    .split('-')
+    .map(word => word[0].toUpperCase() + word.slice(1))
+    .join(' ')
 }

package/lib/src/utils/writeFile.js

@@ -1,15 +1,8 @@
-const { writeFile } = require('node:fs')
+const { writeFile } = require('node:fs/promises')
 
 /**
  * @param {String} filename
  * @param {String} data
- * @returns {Promise<String>}
+ * @returns {Promise<void>}
  */
-module.exports = (filename, data) => {
-  return new Promise((resolve, reject) => {
-    writeFile(filename, data, error => {
-      if (error) reject(error.message)
-      else resolve('Saved successfully')
-    })
-  })
-}
+module.exports = (filename, data) => writeFile(filename, data, 'utf8')

package/lib/templates/api/database/connection.ts.ejs

@@ -0,0 +1,40 @@
+import { PrismaClient } from '@prisma/client'
+import { type Debugger } from 'debug'
+
+let dbConnected = false
+
+declare global {
+  // eslint-disable-next-line no-var
+  var __client__: PrismaClient
+}
+
+const dbConnection = (
+  d?: Debugger
+): {
+  connect: () => Promise<PrismaClient>
+  disconnect: () => Promise<boolean>
+} => {
+  return {
+    connect: async () => {
+      if (!global.__client__) {
+        global.__client__ = new PrismaClient()
+        await global.__client__.$connect()
+        dbConnected = true
+        d?.('<%- dbPrettyName %> connection established.')
+      }
+
+      return global.__client__
+    },
+    disconnect: async () => {
+      if (global.__client__) {
+        dbConnected = false
+        await global.__client__.$disconnect()
+        d?.('<%- dbPrettyName %> connection closed.')
+      }
+
+      return dbConnected
+    }
+  }
+}
+
+export { dbConnection }

package/lib/templates/api/database/db-index.ts.ejs

@@ -0,0 +1,2 @@
+export * from './connection'
+export * from './queries'

package/lib/templates/api/database/index.ts.ejs

@@ -0,0 +1 @@
+export * from './<%- db %>'

package/lib/templates/api/database/queries-entity.ts.ejs

@@ -0,0 +1,98 @@
+import { <%- Entity %> } from '@prisma/client'
+import debug from 'debug'
+
+import { dbConnection } from '../connection'
+import { Id, <%- Entity %> as <%- Entity %>Schema, <%- Entity %>DTO } from 'schemas'
+import { Logger } from 'utils'
+
+const logger = new Logger(debug('App:Database:Queries:<%- Entity %>'), 'queries/<%- entity %>.ts')
+
+const <%- entity %>DBOtoDTO = (<%- entity %>DBO: <%- Entity %>) =>
+  ({
+    ...<%- entity %>DBO,
+    createdAt: <%- entity %>DBO.createdAt.toISOString(),
+    updatedAt: <%- entity %>DBO.updatedAt.toISOString()
+  }) satisfies <%- Entity %>DTO
+
+const store = async (<%- entity %>Data: <%- Entity %>Schema) => {
+  try {
+    const client = await dbConnection().connect()
+    const <%- entity %> = await client.<%- entity %>.create({
+      data: <%- entity %>Data
+    })
+
+    return <%- entity %>DBOtoDTO(<%- entity %>)
+  } catch (error) {
+    logger.log({
+      method: store.name,
+      value: 'error',
+      content: error
+    })
+
+    return null
+  }
+}
+
+const removeById = async (id: Id) => {
+  try {
+    const client = await dbConnection().connect()
+    await client.<%- entity %>.delete({
+      where: { id }
+    })
+
+    return true
+  } catch (error) {
+    logger.log({
+      method: removeById.name,
+      value: 'error',
+      content: error
+    })
+
+    return false
+  }
+}
+
+const getById = async (id: Id) => {
+  try {
+    const client = await dbConnection().connect()
+    const <%- entity %> = await client.<%- entity %>.findUnique({
+      where: { id }
+    })
+
+    if (!<%- entity %>) return null
+
+    return <%- entity %>DBOtoDTO(<%- entity %>)
+  } catch (error) {
+    logger.log({
+      method: getById.name,
+      value: 'error',
+      content: error
+    })
+
+    return null
+  }
+}
+
+const update = async (id: Id, <%- entity %>: <%- Entity %>Schema) => {
+  try {
+    const client = await dbConnection().connect()
+    const <%- entity %>Updated = await client.<%- entity %>.update({
+      where: { id },
+      data: <%- entity %>
+    })
+
+    if (!<%- entity %>Updated) return null
+
+    return <%- entity %>DBOtoDTO(<%- entity %>Updated)
+  } catch (error) {
+    logger.log({
+      method: update.name,
+      value: 'error',
+      content: error
+    })
+
+    return null
+  }
+}
+
+export { store, removeById, getById, update }

package/lib/templates/api/database/queries-index.ts.ejs

@@ -0,0 +1 @@
+export * from './<%-entity%>'

package/lib/templates/api/database/schema.prisma.ejs

@@ -0,0 +1,25 @@
+generator client {
+  provider = "prisma-client-js"
+}
+
+datasource db {
+  provider = "<%- dbPrismaName %>"
+  url      = <% if (db !== 'sqlite') { %>env("DATABASE_URL")<% } else { %>"file:./dev.db"<% } %>
+}
+
+model <%- Entity %> {
+<% if (isMongo) { -%>
+  id       String @id @default(auto()) @map("_id") @db.ObjectId
+<% } else { -%>
+  id       Int    @id @default(autoincrement())
+<% } -%>
+<% const maxFieldLen = Math.max(...entityFields.map(f => f.name.length), 0); -%>
+<% entityFields.forEach(function(f) { -%>
+  <%- f.name.padEnd(maxFieldLen) %> <%- f.prismaType %>
+<% }) -%>
+
+  createdAt DateTime @default(now())
+  updatedAt DateTime @updatedAt
+
+  @@map("<%- entities %>")
+}

package/lib/templates/api/express/network/index.ts.ejs

@@ -0,0 +1,2 @@
+export * from './routes'
+export * from './server'

package/lib/templates/api/express/network/models/entity.ts.ejs

@@ -0,0 +1,21 @@
+import 'reflect-metadata'
+import { Field, <%- dbIsSQL ? 'Int' : 'ID' %>, ObjectType } from 'type-graphql'
+
+@ObjectType()
+class <%- Entity %> {
+  @Field(() => <%- dbIsSQL ? 'Int' : 'ID' %>)
+  id!: number
+
+<% entityFields.forEach(function(f) { -%>
+  @Field()
+  <%- f.name %>!: string
+
+<% }) -%>
+  @Field({ nullable: true })
+  createdAt?: string
+
+  @Field({ nullable: true })
+  updatedAt?: string
+}
+
+export { <%- Entity %> }

package/lib/templates/api/express/network/models/index.ts.ejs

@@ -0,0 +1 @@
+export * from './<%-Entity%>'