feat(update): finish out 1.0 of toolkit

.prettierignore

@@ -1,4 +1,4 @@
-src/templates
+src/templating/templates
 node_modules/
 dist/
 *.html

bin/build.sh

@@ -5,7 +5,7 @@ rm -Rf ./dist
 tsc -p ./tsconfig.json
 cp package.json ./dist
 cp README.md ./dist
-cp -R ./src/templates ./dist
+cp -R ./src/templating/templates ./dist/templating
 cp -R ./bin/ ./dist/
 rm ./dist/bin/build.sh
 

bin/nil-toolkit.js

@@ -39,6 +39,12 @@ const _parseArguments = () => {
   const addSystemParser = subParsers.add_parser('create-system', {
     help: 'Create a new Node In Layers system.',
   })
+  addSystemParser.add_argument('systemName', {
+    help: 'The name for the system.',
+  })
+  addSystemParser.add_argument('systemType', {
+    help: 'typescript, esm, commonjs',
+  })
 
   const args = parser.parse_args()
   if (!args.command) {

eslint.config.mjs

@@ -22,7 +22,7 @@ export default [
   {
     ignores: [
       'coverage/',
-      'src/templates',
+      'src/templating/templates',
       'dist/',
       'eslint.config.mjs',
       'node_modules/',

package.json

@@ -1,7 +1,7 @@
 {
   "name": "@node-in-layers/toolkit",
   "type": "module",
-  "version": "1.1.0",
+  "version": "1.1.1",
   "description": "The official toolkit for creating/updating/maintaining Node In Layer based systems.",
   "main": "index.js",
   "bin": {
@@ -65,7 +65,7 @@
     "typescript": "5.3.3"
   },
   "dependencies": {
-    "@node-in-layers/core": "^1.1.1",
+    "@node-in-layers/core": "^1.1.2",
     "argparse": "^2.0.1",
     "chalk": "^4.1.2",
     "es-main": "^1.3.0",

src/app/index.ts

@@ -2,20 +2,21 @@
 import path, { dirname } from 'node:path'
 import * as glob from 'glob'
 import {
-  FeaturesDependencies,
+  FeaturesContext,
   Config,
-  ServicesDependencies,
+  ServicesContext,
 } from '@node-in-layers/core/index.js'
 import { PackageServicesLayer, PackageType } from '../package/types.js'
 import { Namespace } from '../types.js'
+import { applyTemplates, createValidName } from '../templating/libs.js'
+import { TemplatingServicesLayer } from '../templating/types.js'
 import { AppServicesLayer, AppServices } from './types.js'
-import { applyTemplates, createValidAppName } from './libs.js'
 
 const __filename = fileURLToPath(import.meta.url)
 const __dirname = dirname(__filename)
 
 const services = {
-  create: (deps: ServicesDependencies): AppServices => {
+  create: (deps: ServicesContext): AppServices => {
     const _getPackageJson = async (): Promise<string | undefined> => {
       const wd = `${deps.constants.workingDirectory}/package.json`
       return (await glob.glob(wd)).find(
@@ -45,63 +46,33 @@
 
     const getPackageType = () =>
       Promise.resolve().then(() => {
         // TODO: Add support for non-typescript
         return PackageType.typescript
       })
 
-    const readTemplates = async ({ packageType }) => {
-      const templatePath = path.join(
-        __dirname,
-        `../templates/app/${packageType}/src/**/*`
-      )
-      const paths = (await glob.glob(templatePath, { dot: true })).filter(p =>
-        deps.node.fs.lstatSync(p).isFile()
-      )
-      return paths.map(sourceLocation => {
-        const dirA = path.join(__dirname, `../templates/app/${packageType}`)
-        const relativePath = path.relative(dirA, sourceLocation)
-        const sourceData = deps.node.fs.readFileSync(sourceLocation, 'utf-8')
-        return {
-          relativePath,
-          sourceData,
-        }
-      })
-    }
-
-    const writeTemplates = (appName, templates) => {
-      templates.forEach(t => {
-        const finalLocation = path
-          .join(deps.constants.workingDirectory, t.relativePath)
-          .replaceAll('.handlebars', '')
-          .replaceAll('APP_NAME', appName)
-        const dirPath = path.dirname(finalLocation)
-        deps.node.fs.mkdirSync(dirPath, { recursive: true })
-        deps.node.fs.writeFileSync(finalLocation, t.templatedData)
-      })
-    }
-
     return {
       isPackageRoot,
       doesAppAlreadyExist,
       getPackageName,
       getPackageType,
-      readTemplates,
-      writeTemplates,
     }
   },
 }
 
 const features = {
   create: (
-    deps: FeaturesDependencies<Config, PackageServicesLayer & AppServicesLayer>
+    context: FeaturesContext<
+      Config,
+      PackageServicesLayer & AppServicesLayer & TemplatingServicesLayer
+    >
   ) => {
     const createApp = async ({ appName }: { appName: string }) => {
-      const ourServices = deps.services[Namespace.app]
-      const logger = deps.log.getLogger('nil-toolkit:createApp')
+      const ourServices = context.services[Namespace.app]
+      const logger = context.log.getLogger('nil-toolkit:createApp')
 
-      appName = createValidAppName(appName)
+      appName = createValidName(appName)
 
-      if (!deps.services[Namespace.app].isPackageRoot()) {
+      if (!context.services[Namespace.app].isPackageRoot()) {
         throw new Error(
           `Must be located in the main directory of your node-in-layers system or package. This is the same directory as the package.json.`
         )
@@ -119,14 +90,25 @@
       const packageType = await ourServices.getPackageType()
       logger.info(`Package Type if ${packageType}`)
       logger.info('Reading Templates')
-      const templates = await ourServices.readTemplates({ packageType })
+      const templates = await context.services[
+        Namespace.templating
+      ].readTemplates('app', packageType)
       logger.info('Apply Templates')
-      const appliedTemplates = applyTemplates(templates, {
+      const data = {
+        nodeInLayersCoreVersion:
+          await context.services[
+            Namespace.templating
+          ].getNodeInLayersCoreVersion(),
         packageName,
         appName,
-      })
+      }
+      const appliedTemplates = applyTemplates(templates, data)
       logger.info('Writing templates')
-      ourServices.writeTemplates(appName, appliedTemplates)
+      context.services[Namespace.templating].writeTemplates(
+        appName,
+        appliedTemplates,
+        { ignoreNameInDir: true }
+      )
       logger.info('Operation complete')
     }
     return {

src/app/types.ts

@@ -1,20 +1,11 @@
-import {
-  PackageType,
-  TemplatedFile,
-  FinalizedTemplate,
-} from '../package/types.js'
+import { PackageType } from '../templating/types.js'
 import { Namespace } from '../types.js'
 
 type AppServices = Readonly<{
   isPackageRoot: () => Promise<boolean>
   doesAppAlreadyExist: (appName: string) => boolean
   getPackageName: () => Promise<string>
   getPackageType: () => Promise<PackageType>
-  readTemplates: ({ packageType }) => Promise<readonly TemplatedFile[]>
-  writeTemplates: (
-    appName: string,
-    templates: readonly FinalizedTemplate[]
-  ) => void
 }>
 
 type AppServicesLayer = Readonly<{

src/config.ts

@@ -13,6 +13,7 @@ const create = async (options: {
     environment: 'prod',
     [CoreNamespace.root]: {
       apps: [
+        await import('./templating/index.js'),
         await import('./package/index.js'),
         await import('./app/index.js'),
         await import('./system/index.js'),

src/index.ts

@@ -2,5 +2,4 @@ import { Namespace } from './types.js'
 
 const name = Namespace.root
 
-export * as nilPackage from './package/index.js'
 export { name }

src/package/features.ts

@@ -1,37 +1,55 @@
-import { FeaturesDependencies, Config } from '@node-in-layers/core/index.js'
+import { FeaturesContext, Config } from '@node-in-layers/core/index.js'
 import { Namespace } from '../types.js'
+import { applyTemplates, createValidName } from '../templating/libs.js'
+import { TemplatingServicesLayer } from '../templating/types.js'
 import { PackageServicesLayer, PackageType } from './types.js'
-import { applyTemplates, createValidPackageName } from './libs.js'
 
 const create = (
-  dependencies: FeaturesDependencies<Config, PackageServicesLayer>
+  context: FeaturesContext<
+    Config,
+    PackageServicesLayer & TemplatingServicesLayer
+  >
 ) => {
-  const ourServices = dependencies.services[Namespace.package]
+  const ourServices = context.services[Namespace.package]
+  const templatingServices = context.services[Namespace.templating]
   const createPackage = async ({
     packageName,
     packageType,
   }: {
     packageName: string
     packageType: PackageType
   }) => {
-    packageName = createValidPackageName(packageName)
-    const logger = dependencies.log.getLogger('nil-toolkit:createNewPackage')
+    packageName = createValidName(packageName)
+    const logger = context.log.getLogger('nil-toolkit:createPackage')
     logger.info('Creating package directory')
-    ourServices.createPackageDirectory(packageName)
+    templatingServices.createDirectory(packageName)
     logger.info('Reading templates for all package types')
-    const generalTemplates = await ourServices.readGeneralTemplates()
+    const generalTemplates = await templatingServices.readTemplates(
+      'package',
+      'all'
+    )
     logger.info(`Reading templates for ${packageType} package types`)
-    const specificTemplates = await ourServices.readTemplates(packageType)
+    const specificTemplates = await templatingServices.readTemplates(
+      'package',
+      packageType
+    )
     const templates = generalTemplates.concat(specificTemplates)
     logger.info(`Apply templates`)
-    const appliedTemplates = applyTemplates(templates, { packageName })
-    logger.info(
-      `Writing templates to ${dependencies.constants.workingDirectory}`
-    )
-    ourServices.writeTemplates(packageName, appliedTemplates)
+    const data = {
+      nodeInLayersCoreVersion:
+        await context.services[
+          Namespace.templating
+        ].getNodeInLayersCoreVersion(),
+      packageName,
+    }
+    const appliedTemplates = applyTemplates(templates, data)
+    logger.info(`Writing templates to ${context.constants.workingDirectory}`)
+    templatingServices.writeTemplates(packageName, appliedTemplates)
     if (packageType === PackageType.typescript) {
       logger.info(`Running NPM Install`)
       ourServices.executeNpm(packageName, 'install')
+      logger.info(`Building package`)
+      ourServices.executeNpm(packageName, 'run build')
     }
     logger.info(`Running NPM Prettier`)
     ourServices.executeNpm(packageName, 'run prettier')