fr/nork
1
0
Fork 0
mirror of https://github.com/filiprojek/nork.git synced 2024-11-23 09:11:03 +01:00
Code Issues Packages Projects Releases Wiki Activity

Starting rewriting nork from scratch

Browse Source
This commit is contained in:
Filip Rojek 2024-04-02 21:14:45 +02:00
parent 6a1a6f6e68
commit 2e2352aa57
60 changed files with 42 additions and 1632 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
src/app.ts
View File

@ -1,10 +1,8 @@
#!/usr/bin/env node //import express from "express"
import Routes from './routes' //import morgan from "morgan"
export class App { //export const app = express()
constructor() { //app.use(morgan('dev'))
Routes.router()
}
}
new App() import Log from "./modules/LogService"
export { Log }

97
src/create.ts
View File

@ -1,97 +0,0 @@
import pad from 'pad'
import colors from 'colors'
import fs from 'fs-extra'
import path from 'path'
import global from './global'
import { Create as CreateInterface } from './interfaces/CreateInterface'
import inquirer from 'inquirer'
export default class Create {
static async project(projectName: string | boolean = false) {
// get info about new project
let projectPath
const questions = [
{
type: 'input',
name: 'project_name',
message: 'Enter project name:'
},
{
type: 'list',
message: `Pick the technology you're using:`,
name: 'lang',
choices: [
{ name: 'Typescript', value: 'ts' }
//{ name: 'Javascript - DEPRECATED', value: 'js' }
]
},
{
type: 'list',
message: `Pick the database & ORM you're using:`,
name: 'db',
choices: [
{ name: 'MongoDB - Mongoose', value: { db: 'mongodb', orm: 'mongoose' } },
{ name: 'MySQL - Sequelize', value: { db: 'mysql', orm: 'sequelize' } },
{ name: 'PostgreSQL - Sequelize', value: { db: 'postgresql', orm: 'sequelize' } }
]
},
{
type: 'input',
name: 'author',
message: 'Enter your name:'
},
{
type: 'input',
name: 'email',
message: 'Enter your email:'
},
{
type: 'input',
name: 'website',
message: 'Enter your website:'
}
]
// remove first question if project name is already known
if (projectName) questions.shift()
const answers = await inquirer.prompt(questions)
const data: CreateInterface = {
project_name: answers.project_name ? answers.project_name : process.argv[3],
lang: answers.lang,
author: answers.author,
database: answers.db,
website: answers.website,
email: answers.email
}
// copy skeleton to new project
process.argv.includes('-i') ? (projectPath = process.cwd()) : (projectPath = path.join(process.cwd(), data.project_name))
fs.copySync(path.join(__dirname, './skeletons/express-' + data.lang), projectPath)
// copy default db models to new project
if (data.database.orm == 'mongoose') fs.copySync(path.join(__dirname, './skeletons/mongoose-models/'), projectPath + '/src/models')
if (data.database.orm == 'sequelize') fs.copySync(path.join(__dirname, './skeletons/sequelize-models/'), projectPath + '/src/models')
// edit package.json file
const pkgJson = fs.readJsonSync(path.join(projectPath, 'package.json'))
pkgJson.name = data.project_name
pkgJson.author = `${data.author} <${data.email}> (${data.website})`
fs.writeFile(path.join(projectPath, 'package.json'), JSON.stringify(pkgJson, null, 2), (err) => {
if (err) return global.logError(err.message)
})
// create norkconfig.json
const norkconfig: any = { ...data }
norkconfig['version'] = require('../package.json').version
fs.writeFileSync(path.join(projectPath, 'norkconfig.json'), JSON.stringify(norkconfig, null, 2))
console.log(colors.yellow('Project settings'))
console.log(colors.yellow('------------------'))
console.log(pad(colors.gray('Project name: '), 30), data.project_name)
console.log(pad(colors.gray('Author: '), 30), pkgJson.author)
console.log(pad(colors.gray('Language: '), 30), global.langToLanguage(String(data.lang)))
console.log(pad(colors.gray('Database: '), 30), global.dbToDatabase(String(data.database.db)))
return global.logSuccess(`Project ${data.project_name} created successfully!`)
}
}

40
src/global.ts
View File

@ -1,40 +0,0 @@
import colors from 'colors'
export default class Global {
static logSuccess = (msg: boolean | string = false): string => {
if (!msg) {
msg = 'Success!'
}
console.log(colors.cyan(String(msg)))
return String(msg)
}
static logError(errorMsg: string) {
console.log(colors.bgYellow.red(errorMsg))
return
}
static langToLanguage(lang: string): string {
switch (lang) {
case 'js':
return 'Javascript'
case 'ts':
return 'Typescript'
default:
return 'Unknown language'
}
}
static dbToDatabase(lang: string): string {
switch (lang) {
case 'mongodb':
return 'MongoDB'
case 'postgresql':
return 'PostgreSQL'
case 'mysql':
return 'MySQL'
default:
return 'Unknown database'
}
}
}

66
src/help.ts
View File

@ -1,66 +0,0 @@
import pad from 'pad'
import colors from 'colors'
export default class Help {
constructor() {
// this.logHelp()
}
// log help & returns status in string for tests
static makeHelp(): string {
const spc = 27
return `
Usage: make:[component]
${pad(' make controller [name]', spc)} create a new controller
${pad(' make middleware [name]', spc)} create a new middleware
${pad(' make model [name]', spc)} create a new model
${pad(' make route [name]', spc)} create a new route
${pad(' make test [name]', spc)} create a new test
${pad(' make view [name]', spc)} create a new view
`
}
static allHelp(): string {
const spc = 27
return `
Usage: nork <command> [options]
Options:
${pad(' -v, --version', spc)} output the version number
${pad(' -h, --help', spc)} output usage information
Commands:
${pad(' create [app-name]', spc)} create a new project
${pad(' create [app-name] -i', spc)} create a new project in current directory
${pad(' make controller [name]', spc)} create a new controller
${pad(' make interface [name]', spc)} create a new interface
${pad(' make middleware [name]', spc)} create a new middleware
${pad(' make model [name]', spc)} create a new model
${pad(' make route [name]', spc)} create a new route
${pad(' make service [name]', spc)} create a new service
${pad(' make test [name]', spc)} create a new test
${pad(' make view [name]', spc)} create a new view
${pad(' setup', spc)} set up an existing project for nork
Run ${colors.cyan('nork help <command>')} for detailed usage of given command.
`
}
static specificHelp(specific: string): string {
return `Usage: ${specific} [options]`
}
static logHelp = (specific: boolean | string = false): string => {
if (specific) {
// log specific help
if (specific == 'make') {
return this.makeHelp()
}
// else return specific help
return this.specificHelp(String(specific))
}
// if nothing return help all
return this.allHelp()
}
}

13
src/interfaces/CreateInterface.ts
View File

@ -1,13 +0,0 @@
interface database {
db: string
orm: string
}
export interface Create {
project_name: string
author: string
lang: string
database: database
email: string
website: string
}

3
src/interfaces/GlobalInterface.ts
View File

@ -1,3 +0,0 @@
export interface Norkcfg {
lang: string
}

15
src/interfaces/SetupInterface.ts
View File

@ -1,15 +0,0 @@
export interface Questions {
type: string
message: string
name: string
choices: [
{
name: string
value: string
},
{
name: string
value: string
}
]
}

4
src/interfaces/test.ts
View File

@ -1,4 +0,0 @@
export interface interfaceName {
hello: string
world: boolean | null | undefined
}

6
src/make-files/express-ts/controller.ts
View File

@ -1,6 +0,0 @@
import { Request, Response } from 'express'
export const root_get = (req: Request, res: Response) => {
res.render('home')
return true
}

4
src/make-files/express-ts/interface.ts
View File

@ -1,4 +0,0 @@
export interface interfaceName {
hello: string
world: boolean | null | undefined
}

8
src/make-files/express-ts/middleware.ts
View File

@ -1,8 +0,0 @@
import { Router, Request, Response, NextFunction } from 'express'
export const router = Router()
router.use((req: Request, res: Response, next: NextFunction) => {
console.log('Hi :)')
next()
})

15
src/make-files/express-ts/model.ts
View File

@ -1,15 +0,0 @@
import { Schema, model } from 'mongoose'
const modelSchema = new Schema<any>(
{
title: {
type: String,
required: true
}
},
{
timestamps: true
}
)
export default model('ModelName', modelSchema)

6
src/make-files/express-ts/route.ts
View File

@ -1,6 +0,0 @@
import { Router } from 'express'
import * as rootController from '@/controllers/rootController'
export const router = Router()
router.get('/', rootController.root_get)

3
src/make-files/express-ts/service.ts
View File

@ -1,3 +0,0 @@
export function helloWorld() {
console.log('hello world')
}

15
src/make-files/express-ts/view.ejs
View File

@ -1,15 +0,0 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>New Project</title>
<link rel="preconnect" href="https://fonts.googleapis.com">
<link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
<link href="https://fonts.googleapis.com/css2?family=Open+Sans&display=swap" rel="stylesheet">
</head>
<body>
</body>
</html>

76
src/make.ts
View File

@ -1,76 +0,0 @@
import path from 'path'
import fs from 'fs-extra'
import global from './global'
import { Norkcfg } from './interfaces/GlobalInterface'
export default class Make {
static component(component: string) {
// const norkcfg = require(path.join(process.cwd(), 'norkconfig.json'))
const norkcfg: Norkcfg = fs.readJsonSync(path.join(process.cwd(), 'norkconfig.json'))
const tsComponents = ['controller', 'middleware', 'route', 'service']
if (tsComponents.includes(component)) {
const src = path.join(__dirname, './make-files/express-' + norkcfg.lang + '/' + component + '.' + norkcfg.lang)
const dest = path.join(process.cwd(), './src/' + component + 's' + '/' + process.argv[4] + '.' + norkcfg.lang)
try {
fs.copySync(src, dest, { overwrite: false, errorOnExist: true })
} catch (err: any) {
return global.logError(err.message)
}
return global.logSuccess()
}
if (component == 'model') {
const src = path.join(__dirname, './make-files/express-' + norkcfg.lang + '/' + component + '.' + norkcfg.lang)
const dest = path.join(process.cwd(), './src/' + component + 's' + '/' + process.argv[4] + '.' + norkcfg.lang)
try {
fs.copySync(src, dest, { overwrite: false, errorOnExist: true })
} catch (err: any) {
return global.logError(err.message)
}
return global.logSuccess()
}
if (component == 'view') {
const src = path.join(__dirname, './make-files/express-' + norkcfg.lang + '/' + component + '.ejs')
const dest = path.join(process.cwd(), './src/' + component + 's' + '/' + process.argv[4] + '.ejs')
try {
fs.copySync(src, dest, { overwrite: false, errorOnExist: true })
} catch (err: any) {
return global.logError(err.message)
}
return global.logSuccess()
}
if (component == 'test') {
const src = path.join(__dirname, './make-files/express-' + norkcfg.lang + '/' + component + '.js')
const dest = path.join(process.cwd(), './src/' + component + 's' + '/' + process.argv[4] + '.test.js')
try {
fs.copySync(src, dest, { overwrite: false, errorOnExist: true })
} catch (err: any) {
return global.logError(err.message)
}
return global.logSuccess()
}
if (component == 'interface') {
if (norkcfg.lang != 'ts') {
return global.logError('error - this is typescript only component')
}
const src = path.join(__dirname, './make-files/express-' + norkcfg.lang + '/' + component + '.ts')
const dest = path.join(process.cwd(), './src/' + component + 's' + '/' + process.argv[4] + '.ts')
try {
fs.copySync(src, dest, { overwrite: false, errorOnExist: true })
} catch (err: any) {
return global.logError(err.message)
}
return global.logSuccess()
}
return global.logError(`error - unknown component ${component}`)
}
}

35
src/modules/LogService.ts Normal file
View File

@ -0,0 +1,35 @@
import colors from 'colors'
import fs from 'fs'
import path from 'path'
export default class Log {
public static info(code: number, message: string, data?:any): void {
if(!data) {
data = ""
}
console.log(colors.bgGreen.black(` ${code} `) + colors.green.bgBlack(` ${message} `) + data)
}
public static error(code: number, message: string, data?:any): void {
if(!data) {
data = ""
}
console.log(colors.bgRed.black(` ${code} `) + colors.red.bgBlack(` ${message} `) + data)
//this.writeLog('error', code, message, data)
}
private static writeLog(level: string, code: number, message: string, data?:any): void {
if(data) {
data = JSON.stringify(data)
}
try {
throw Error("nevim")
} catch (error) {
this.error(500, 'Error while writing to log file', error)
return
}
}
}

49
src/routes.ts
View File

@ -1,49 +0,0 @@
import Help from './help'
import Version from './version'
import Setup from './setup'
import Make from './make'
import Create from './create'
export default class Routes {
static router(): string {
if (process.argv[2] == 'help' || process.argv[2] == '-h' || process.argv[2] == '--help') {
if (process.argv[3]) {
console.log(Help.logHelp(process.argv[3]))
return 'specific help'
}
console.log(Help.logHelp())
return 'all help'
}
if (process.argv[2] == '-v' || process.argv[2] == '--version') {
console.log(Version.show())
return 'version'
}
if (process.argv[2] == 'setup') {
if (process.argv[3] != 'test') {
Setup.setup()
}
return 'setup'
}
if (process.argv[2] == 'make') {
if (process.argv[3]) {
if (process.argv[4] != 'test') {
Make.component(process.argv[3])
}
return `make ${process.argv[3]}`
}
}
if (process.argv[2] == 'create') {
if (process.argv[4] != 'test') {
Create.project(process.argv[3])
}
return `create ${process.argv[3]}`
}
console.log(Help.logHelp())
return 'all help'
}
}

24
src/setup.ts
View File

@ -1,24 +0,0 @@
import inquirer from 'inquirer'
import fs from 'fs-extra'
import path from 'path'
import Global from './global'
import { Questions } from './interfaces/SetupInterface'
export default class Setup {
static async setup(test = false) {
if (!test) {
const questions: Questions = {
type: 'list',
message: `Pick the technology you're using:`,
name: 'lang',
choices: [
{ name: 'Typescript', value: 'ts' },
{ name: 'Javascript', value: 'js' }
]
}
const answers = await inquirer.prompt(Object(questions))
fs.writeJsonSync(path.join(process.cwd(), './norkconfig.json'), answers)
}
return Global.logSuccess()
}
}

12
src/skeletons/composes/mariadb.yaml
View File

@ -1,12 +0,0 @@
version: '3.1'
services:
db:
image: mariadb
restart: always
environment:
MARIADB_ROOT_PASSWORD: root
MARIADB_USER: nork
MARIADB_PASSWORD: nork
volumes:
./db-data:/var/lib/mysql

20
src/skeletons/composes/mongodb.yaml
View File

@ -1,20 +0,0 @@
# Use root/example as user/password credentials
version: '3.1'
services:
mongo:
image: mongo
restart: always
environment:
MONGO_INITDB_ROOT_USERNAME: root
MONGO_INITDB_ROOT_PASSWORD: root
mongo-express:
image: mongo-express
restart: always
ports:
- 8081:8081
environment:
ME_CONFIG_MONGODB_ADMINUSERNAME: root
ME_CONFIG_MONGODB_ADMINPASSWORD: root
ME_CONFIG_MONGODB_URL: mongodb://root:example@mongo:27017/

59
src/skeletons/express-ts/.githooks/pre-push
View File

@ -1,59 +0,0 @@
#!/bin/bash
# @link https://gist.github.com/mattscilipoti/8424018
#
# Called by "git push" after it has checked the remote status,
# but before anything has been pushed.
#
# If this script exits with a non-zero status nothing will be pushed.
#
# Steps to install, from the root directory of your repo...
# 1. Copy the file into your repo at `.git/hooks/pre-push`
# 2. Set executable permissions, run `chmod +x .git/hooks/pre-push`
# 3. Or, use `rake hooks:pre_push` to install
#
# Try a push to master, you should get a message `*** [Policy] Never push code directly to...`
#
# The commands below will not be allowed...
# `git push origin master`
# `git push --force origin master`
# `git push --delete origin master`
protected_branch='master'
policy="\n\n[Policy] Never push code directly to the "$protected_branch" branch! (Prevented with pre-push hook.)\n\n"
current_branch=$(git symbolic-ref HEAD | sed -e 's,.*/\(.*\),\1,')
push_command=$(ps -ocommand= -p $PPID)
is_destructive='force|delete|\-f'
will_remove_protected_branch=':'$protected_branch
do_exit(){
echo -e $policy
exit 1
}
if [[ $push_command =~ $is_destructive ]] && [ $current_branch = $protected_branch ]; then
do_exit
fi
if [[ $push_command =~ $is_destructive ]] && [[ $push_command =~ $protected_branch ]]; then
do_exit
fi
if [[ $push_command =~ $will_remove_protected_branch ]]; then
do_exit
fi
# Prevent ALL pushes to protected_branch
if [[ $push_command =~ $protected_branch ]] || [ $current_branch = $protected_branch ]; then
do_exit
fi
unset do_exit
exit 0

107
src/skeletons/express-ts/.gitignore vendored
View File

@ -1,107 +0,0 @@
# Logs
#logs
*.log
npm-debug.log*
yarn-debug.log*
yarn-error.log*
lerna-debug.log*
# Diagnostic reports (https://nodejs.org/api/report.html)
report.[0-9]*.[0-9]*.[0-9]*.[0-9]*.json
# Runtime data
pids
*.pid
*.seed
*.pid.lock
# Directory for instrumented libs generated by jscoverage/JSCover
lib-cov
# Coverage directory used by tools like istanbul
coverage
*.lcov
# nyc test coverage
.nyc_output
# Grunt intermediate storage (https://gruntjs.com/creating-plugins#storing-task-files)
.grunt
# Bower dependency directory (https://bower.io/)
bower_components
# node-waf configuration
.lock-wscript
# Compiled binary addons (https://nodejs.org/api/addons.html)
build/Release
# Dependency directories
node_modules/
jspm_packages/
# TypeScript v1 declaration files
typings/
# TypeScript cache
*.tsbuildinfo
# Optional npm cache directory
.npm
# Optional eslint cache
.eslintcache
# Microbundle cache
.rpt2_cache/
.rts2_cache_cjs/
.rts2_cache_es/
.rts2_cache_umd/
# Optional REPL history
.node_repl_history
# Output of 'npm pack'
*.tgz
# Yarn Integrity file
.yarn-integrity
# dotenv environment variables file
.env
.env.test
# parcel-bundler cache (https://parceljs.org/)
.cache
# Next.js build output
.next
# Nuxt.js build / generate output
.nuxt
dist
# Gatsby files
.cache/
# Comment in the public line in if your project uses Gatsby and *not* Next.js
# https://nextjs.org/blog/next-9-1#public-directory-support
# public
# vuepress build output
.vuepress/dist
# Serverless directories
.serverless/
# FuseBox cache
.fusebox/
# DynamoDB Local files
.dynamodb/
# TernJS port file
.tern-port
# package lock file
package-lock.json

15
src/skeletons/express-ts/.prettierrc
View File

@ -1,15 +0,0 @@
{
"tabWidth": 4,
"useTabs": true,
"singleQuote": true,
"semi": false,
"trailingComma": "none",
"jsxSingleQuote": true,
"jsxBracketSameLine": true,
"printWidth": 200,
"bracketSpacing": true,
"vueIndentScriptAndStyle": true,
"arrowParens": "always",
"bracketSameLine": false,
"endOfLine": "lf"
}

1
src/skeletons/express-ts/README.md
View File

@ -1 +0,0 @@
# New Project

5
src/skeletons/express-ts/norkconfig.json
View File

@ -1,5 +0,0 @@
{
"lang": "ts",
"db": "",
"orm": ""
}

73
src/skeletons/express-ts/package.json
View File

@ -1,73 +0,0 @@
{
"name": "project-name",
"version": "1.0.0",
"description": "",
"main": "dist/server.js",
"private": "true",
"keywords": [],
"author": "",
"repository": "github:username/repo",
"license": "ISC",
"scripts": {
"start": "node dist/server.js",
"start:dev": "nodemon src/server.ts",
"test": "jest",
"clean": "rimraf dist/*",
"copy-assets": "npx ts-node src/utils/copyAssets",
"tsc": "tsc -p .",
"build": "npm-run-all clean tsc copy-assets",
"format": "npx prettier --write ."
},
"dependencies": {
"colors": "1.4.0",
"cookie-parser": "^1.4.5",
"cors": "^2.8.5",
"dotenv": "^8.2.0",
"ejs": "^3.1.6",
"express": "^4.17.1",
"express-validator": "^6.14.2",
"fs-extra": "^10.0.0",
"jsonwebtoken": "^8.5.1",
"mongoose": "^5.12.3",
"pg": "^8.7.1",
"pg-hstore": "^2.3.4",
"sequelize": "^6.15.0"
},
"devDependencies": {
"@types/cookie-parser": "^1.4.2",
"@types/cors": "^2.8.10",
"@types/ejs": "^3.0.6",
"@types/express": "^4.17.11",
"@types/fs-extra": "^9.0.12",
"@types/jest": "^27.5.2",
"@types/jsonwebtoken": "^8.5.8",
"@types/mongoose": "^5.10.5",
"@types/morgan": "^1.9.2",
"@types/node": "^14.14.41",
"@types/shelljs": "^0.8.9",
"jest": "^27.0.6",
"npm-run-all": "^4.1.5",
"rimraf": "^3.0.2",
"shelljs": "^0.8.4",
"ts-jest": "^27.1.5",
"ts-node": "^10.8.1",
"typescript": "^4.2.4",
"morgan": "^1.10.0"
},
"jest": {
"preset": "ts-jest",
"testEnvironment": "node"
},
"nodemonConfig": {
"ignore": [
"**/*.test.ts",
"**/*.spec.ts",
".git",
"node_modules"
],
"watch": [
"src"
],
"ext": "ts, js"
}
}

5
src/skeletons/express-ts/setup-repo.sh
View File

@ -1,5 +0,0 @@
#!/bin/bash
cp .githooks/* .git/hooks
echo "hooks have been copied"

26
src/skeletons/express-ts/src/.env.example
View File

@ -1,26 +0,0 @@
# General
APP_PORT = 6060
APP_HOSTNAME = 'localhost'
APP_HOST = 'http://localhost:8080' # frontend url
# Timezone
TZ = 'Europe/Prague'
CORS_WHITELIST = http://172.15.46.21:8080;http://192.168.0.1:8080
JWT_SECRET = ''
# MongoDB
DB_URI = 'mongodb://username:password@localhost:27017/database?authSource=admin'
# PostgreSQL
DB_PORT = 5432
DB_HOST = '127.0.0.1'
DB_USERNAME = ''
DB_PASSWORD = ''
DB_DATABASE = ''
# SMTP
SMTP_HOST = ''
SMTP_USER = ''
SMTP_PASS = ''
SMTP_FROM = ''

42
src/skeletons/express-ts/src/app.ts
View File

@ -1,42 +0,0 @@
import express from 'express'
import morgan from 'morgan'
import path from 'path'
import cors from 'cors'
import cookieParser from 'cookie-parser'
import { router as routes } from './routes'
import { router as middlewares } from './middlewares'
import env from './config/environment'
export let corsWhitelist: Array<string>
if (env.CORS_WHITELIST != 'undefined') {
corsWhitelist = [...['http://localhost:8080', 'http://localhost:6040'], ...env.CORS_WHITELIST.split(';')]
} else {
corsWhitelist = ['http://localhost:8080', 'http://localhost:6040']
}
const corsOptions = {
origin: function (origin: any, callback: any) {
if (!origin || corsWhitelist.indexOf(origin) !== -1) {
callback(null, true)
} else {
callback(new Error('Not allowed by CORS'))
}
},
optionsSuccessStatus: 200,
credentials: true
}
export const app = express()
// Middlewares
app.use(middlewares)
app.set('view engine', 'ejs')
app.set('views', path.join(__dirname, 'views'))
app.use(cors(corsOptions))
app.use(morgan('dev'))
app.use(express.urlencoded({ extended: true }))
app.use(express.json())
app.use(express.static(path.join(__dirname, 'public')))
app.use(cookieParser())
// Routes
app.use(routes)

49
src/skeletons/express-ts/src/config/database.ts
View File

@ -1,49 +0,0 @@
import mongoose from 'mongoose'
import env from './environment'
import { Err, Succ } from '../services/globalService'
import db from './sequelize.config'
// MongoDB
const dbURI: string = env.DB_URI
function connect() {
if (!env.NORK.database) {
new Err(500, 'no database is in norkcfg.json')
return false
}
if (env.NORK.database.orm == 'mongoose') {
mongoose
.connect(dbURI, {
useNewUrlParser: true,
useUnifiedTopology: true,
useCreateIndex: true
})
.then(() => {
new Succ(200, 'connected to db')
return true
})
.catch((err: any) => {
new Err(500, err)
return false
})
}
if (env.NORK.database.orm == 'sequelize') {
db.sync()
.then(() => {
new Succ(200, 'connected to db')
return true
})
.catch((err: any) => {
new Err(500, `Can't connect to db\n${err}`)
return false
})
}
if (env.NORK.database.db.length > 0) {
new Err(500, `unsupported database ${env.NORK.database.db}`)
return false
}
}
export default connect

59
src/skeletons/express-ts/src/config/environment.ts
View File

@ -1,59 +0,0 @@
import path from 'path'
import fs from 'fs-extra'
import { Err } from '../services/globalService'
import dotenv from 'dotenv'
const env_path = process.env.NODE_ENV ? `../.env.${process.env.NODE_ENV}` : '../.env'
dotenv.config({ path: path.join(__dirname, env_path) })
const norkcfg = fs.readJSONSync(path.join(__dirname, '../../norkconfig.json'))
if (norkcfg.database) {
if (norkcfg.database.db == 'postgresql') {
if (!process.env.DB_PORT) {
process.env.DB_PORT = '5432'
}
if (!process.env.DB_HOST) {
process.env.DB_HOST = '127.0.0.1'
}
if (!process.env.DB_USERNAME || !process.env.DB_PASSWORD || !process.env.DB_DATABASE) {
new Err(500, 'missing DB parameters in .env file')
process.exit(1)
}
}
}
if (!fs.existsSync(path.join(__dirname, env_path))) {
console.log('$env_path = ', env_path)
console.log('$__dirname = ', __dirname)
new Err(500, `.env file for ${process.env.NODE_ENV ? process.env.NODE_ENV : ''} environment does not exists`)
process.exit()
}
if (process.env.JWT_SECRET === undefined || process.env.JWT_SECRET == '') {
new Err(500, 'JWT_SECRET is not set!')
process.exit()
}
export default {
// General
APP_PORT: Number(process.env.APP_PORT),
APP_HOST: String(process.env.APP_HOST),
APP_HOSTNAME: process.env.APP_HOSTNAME !== undefined ? String(process.env.APP_HOSTNAME) : null,
CORS_WHITELIST: String(process.env.CORS_WHITELIST),
JWT_SECRET: String(process.env.JWT_SECRET),
// MongoDB
DB_URI: String(process.env.DB_URI),
// PostgreSQL
DB_PORT: Number(process.env.DB_PORT),
DB_HOST: String(process.env.DB_HOST),
DB_USERNAME: String(process.env.DB_USERNAME),
DB_PASSWORD: String(process.env.DB_PASSWORD),
DB_DATABASE: String(process.env.DB_DATABASE),
// Nork
NORK: norkcfg,
// SMTP
SMTP_HOST: String(process.env.SMTP_HOST),
SMTP_USER: String(process.env.SMTP_USER),
SMTP_PASS: String(process.env.SMTP_PASS),
SMTP_FROM: String(process.env.SMTP_FROM)
}

10
src/skeletons/express-ts/src/config/sequelize.config.ts
View File

@ -1,10 +0,0 @@
import { Sequelize } from 'sequelize'
import env from './environment'
const db = new Sequelize(env.DB_DATABASE, env.DB_USERNAME, env.DB_PASSWORD, {
host: env.DB_HOST,
dialect: 'postgres',
logging: false
})
export default db

6
src/skeletons/express-ts/src/controllers/rootController.ts
View File

@ -1,6 +0,0 @@
import { Request, Response } from 'express'
export function root_get(req: Request, res: Response) {
res.render('home')
return true
}

4
src/skeletons/express-ts/src/interfaces/globalInterface.ts
View File

@ -1,4 +0,0 @@
export interface ErrType {
code: number
message: string
}

1
src/skeletons/express-ts/src/logs/.gitignore vendored
View File

@ -1 +0,0 @@
*.log

63
src/skeletons/express-ts/src/middlewares/authMiddleware.ts
View File

@ -1,63 +0,0 @@
import { Request, Response, NextFunction } from 'express'
import jwt from 'jsonwebtoken'
import env from '../config/environment'
import { Err, Succ } from '../services/globalService'
import User from '../models/User' // uncomment this
export function requireAuth(req: Request, res: Response, next: NextFunction) {
const token = req.cookies.jwt
new Err(500, 'uncomment code in authMiddleware before using!')
if (token) {
jwt.verify(token, env.JWT_SECRET, async (err: any, decodedToken: any) => {
if (err) {
// console.error(err.message)
res.status(401).json(new Err(401, 'user is not authenticated'))
}
if (!err) {
const user = (async () => {
if (env.NORK.db.orm) {
if (env.NORK.db.orm == 'sequelize') {
return await User.findByPk(decodedToken.id)
}
if (env.NORK.db.orm == 'mongoose') {
return await User.findById(decodedToken.id)
}
} else {
return null
}
})()
if (user === null) {
res.status(401).json(new Err(401, 'user is not authenticated'))
return
}
res.locals.user = user
new Succ(100, 'user is authenticated')
next()
}
})
}
if (!token) {
res.status(401).json(new Err(401, 'user is not authenticated'))
}
}
export function requireVerified(req: Request, res: Response, next: NextFunction) {
if (res.locals.user._id) {
if (res.locals.user.verified) {
new Succ(100, 'user is verified')
next()
return
}
res.status(403).json(new Err(403, 'user is not verified'))
return
}
if (!res.locals.user._id) {
res.status(401).json(new Err(401, 'user is not authenticated'))
return
}
}

16
src/skeletons/express-ts/src/middlewares/handleValidation.ts
View File

@ -1,16 +0,0 @@
import { Request, Response, NextFunction } from 'express'
import { validationResult } from 'express-validator'
import { Err } from '../services/globalService'
class Middleware {
handleValidationError(req: Request, res: Response, next: NextFunction) {
const error = validationResult(req)
if (!error.isEmpty()) {
new Err(400, error)
return res.status(400).json(new Err(400, 'validation error', error.array()[0]))
}
next()
}
}
export default new Middleware()

6
src/skeletons/express-ts/src/middlewares/index.ts
View File

@ -1,6 +0,0 @@
import { Router } from 'express'
import { router as sayHiMiddleware } from '../middlewares/sayHiMiddleware'
export const router = Router()
// router.use(sayHiMiddleware)

9
src/skeletons/express-ts/src/middlewares/sayHiMiddleware.ts
View File

@ -1,9 +0,0 @@
import { Router, Request, Response, NextFunction } from 'express'
export const router = Router()
router.use((req: Request, res: Response, next: NextFunction) => {
console.log('Hi :)')
next()
})

BIN
src/skeletons/express-ts/src/public/expressjs.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 4.9 KiB

1
src/skeletons/express-ts/src/public/nodejs_logo.svg
View File

File diff suppressed because one or more lines are too long
Side by Side

Before

Width:  |  Height:  |  Size: 5.8 KiB

11
src/skeletons/express-ts/src/routes/index.ts
View File

@ -1,11 +0,0 @@
import { Request, Response, Router } from 'express'
import { router as rootRoutes } from './rootRoutes'
export const router = Router()
router.use(rootRoutes)
// 404
router.use((req: Request, res: Response) => {
res.status(404).send('E404')
})

9
src/skeletons/express-ts/src/routes/rootRoutes.ts
View File

@ -1,9 +0,0 @@
import { Router } from 'express'
import * as rootController from '../controllers/rootController'
import rootValidator from '../validators/rootValidator'
import handleValidation from '../middlewares/handleValidation'
export const router = Router()
const mws = [handleValidation.handleValidationError]
router.get('/', rootValidator.checkRootGet(), mws, rootController.root_get)

24
src/skeletons/express-ts/src/server.ts
View File

@ -1,24 +0,0 @@
import http from 'http'
import { app } from './app'
import env from './config/environment'
import { Succ } from './services/globalService'
import database from './config/database'
const port: number = env.APP_PORT || 8080
const hostname: string = env.APP_HOSTNAME || 'localhost'
export const server = http.createServer(app)
// Server
export function runServer(): void {
server.listen(port, hostname, () => {
new Succ(200, `Server is listening on http://${hostname}:${port}`)
})
}
if (!env.NORK.database) {
runServer()
} else {
const db_connection = database()
if (db_connection) {
runServer()
}
}

173
src/skeletons/express-ts/src/services/globalService.ts
View File

@ -1,173 +0,0 @@
import colors from 'colors'
import fs from 'fs'
import path from 'path'
export interface ErrType {
code: number
message: string
data?: any
}
export class Err implements ErrType {
code: number
message: string
data: any
constructor(code: number, message: string | object, data: any = null) {
this.code = code
typeof message === 'object' ? (this.message = JSON.stringify(message)) : (this.message = message)
data ? (this.data = data) : false
// typeof data === 'object' ? (this.data = JSON.stringify(data)) : (this.data = data)
this.drop()
}
drop() {
if (this.data) {
console.log(colors.bgRed(`${this.code}`) + colors.bgBlack.red(` ${this.message}`) + this.data)
Log.make('Err', this.code, this.message, this.data)
return {
code: this.code,
message: this.message,
data: this.data
}
}
console.log(colors.bgRed(`${this.code}`) + colors.bgBlack.red(` ${this.message}`))
Log.make('Err', this.code, this.message)
return {
code: this.code,
message: this.message
}
}
}
export class Succ {
code: number
message: string
data?: any
constructor(code: number, message: string, data: any = null) {
this.code = code
this.message = message
data ? (this.data = data) : false
this.drop()
}
drop() {
if (this.data) {
console.log(colors.bgGreen.black(`${this.code}`) + colors.green.bgBlack(` ${this.message}`) + this.data)
return {
code: this.code,
message: this.message,
data: this.data
}
}
console.log(colors.bgGreen.black(`${this.code}`) + colors.green.bgBlack(` ${this.message}`))
return {
code: this.code,
message: this.message
}
}
}
export interface LogType {
type: 'Err' | 'Succ' | 'Info'
code?: number
message?: string
data?: any
logFile?: string
}
export class Log implements LogType {
type: 'Err' | 'Succ' | 'Info'
code?: number
message?: string
data?: any
logFile?: string
/**
* @param type
* - Type of log
* - Err | Succ | Info
* @param code
* - not required
* - HTTP status code
* @param message
* - could be anything
* @param data
* - could be anything
* @param logFile
* - name of logFile
* - default is log type file
*/
constructor(type: 'Err' | 'Succ' | 'Info', code?: number, message?: string, data?: any, logFile?: string) {
this.type = type
this.code = code
this.message = message
this.data = data
this.logFile = logFile
if (!this.logFile) {
this.logFile = `${type}.global.log`
} else {
this.logFile = this.logFile + '.log'
}
this.logFile = path.join(__dirname, this.logFile)
}
static pathMake(type: string, name?: string) {
let logName
if (!name) {
logName = `${type}.global.log`
} else {
logName = name + '.log'
}
return path.join(__dirname, '../logs/' + logName)
}
/**
* returns current date in my custom format
*/
static dateNow(): string {
/**
* @param num: number
*
* receives number and returns two digits number
* example:
* input num = 9 => returns string 09
*/
function add0(num: number): string {
if (num.toString().length <= 1) {
return '0' + String(num)
}
return String(num)
}
const d = new Date()
return `${d.getFullYear()}-${add0(d.getMonth() + 1)}-${add0(d.getDate())} ${add0(d.getHours())}:${add0(d.getMinutes())}:${add0(d.getSeconds())}`
}
static make(type: 'Err' | 'Succ' | 'Info', code?: number, message?: string, data?: any, logFile?: string) {
let realPath = Log.pathMake(type, logFile)
let formattedData = `Date: "${Log.dateNow()}" Type: "${type}"`
code ? (formattedData += ` Code: "${code}"`) : false
message ? (formattedData += ` Message: "${message}"`) : false
if (data) {
if (typeof data === 'object') {
data = JSON.stringify(data)
}
formattedData += ` Data: "${data}"`
}
formattedData += '\n'
if (fs.existsSync(realPath)) {
fs.appendFileSync(realPath, formattedData)
} else {
fs.writeFileSync(realPath, formattedData)
}
}
}

3
src/skeletons/express-ts/src/services/rootService.ts
View File

@ -1,3 +0,0 @@
export const helloWorld = () => {
console.log('hello world')
}

7
src/skeletons/express-ts/src/utils/copyAssets.ts
View File

@ -1,7 +0,0 @@
import * as shell from 'shelljs'
// Copy all the view templates
shell.cp('-R', 'src/views', 'dist/')
shell.cp('-R', 'src/public', 'dist/')
shell.cp('-R', 'src/models', 'dist/')
shell.cp('-u', 'src/.env', 'dist/')

9
src/skeletons/express-ts/src/validators/rootValidator.ts
View File

@ -1,9 +0,0 @@
import { body, param, query } from 'express-validator'
class rootValidator {
checkRootGet() {
return []
}
}
export default new rootValidator()

69
src/skeletons/express-ts/src/views/home.ejs
View File

@ -1,69 +0,0 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>New Project</title>
<link rel="preconnect" href="https://fonts.googleapis.com">
<link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
<link href="https://fonts.googleapis.com/css2?family=Open+Sans&display=swap" rel="stylesheet">
<style>
* {
box-sizing: border-box;
margin: 0;
padding: 0;
}
body {
font-family: 'Open Sans', sans-serif;
}
.content {
width: 100vw;
height: 100vh;
display: flex;
justify-content: space-between;
padding-top: 5rem;
flex-direction: column;
}
footer, .welcome {
display: flex;
justify-content: center;
}
.welcome {
display: flex;
justify-content: center;
align-items: center;
flex-direction: column;
}
img {
width: 200px;
padding-top: 2rem;
}
footer {
padding-bottom: 2rem;
text-align: center;
}
.logos {
display: flex;
align-items: center;
gap: 1rem;
}
</style>
</head>
<body>
<div class="content">
<div class="welcome">
<h1>Let's make something amazing!</h1>
<div class="logos">
<img src="/nodejs_logo.svg" alt="node.js logo">
<img src="/expressjs.png" alt="express.js logo">
</div>
</div>
<footer>
<div class="author">
<p>Made by </p><a href="http://www.filiprojek.cz">filiprojek.cz</a>
</div>
</footer>
</div>
</body>
</html>

63
src/skeletons/express-ts/tsconfig.json
View File

@ -1,63 +0,0 @@
{
"compilerOptions": {
/* Visit https://aka.ms/tsconfig.json to read more about this file */
/* Basic Options */
// "incremental": true, /* Enable incremental compilation */
"target": "es6",
/* Specify ECMAScript target version: 'ES3' (default), 'ES5', 'ES2015', 'ES2016', 'ES2017', 'ES2018', 'ES2019', 'ES2020', or 'ESNEXT'. */
"module": "commonjs",
/* Specify module code generation: 'none', 'commonjs', 'amd', 'system', 'umd', 'es2015', 'es2020', or 'ESNext'. */
// "lib": [], /* 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', 'react', 'react-jsx' or 'react-jsxdev'. */
// "declaration": true, /* Generates corresponding '.d.ts' file. */
// "declarationMap": true, /* Generates a sourcemap for each corresponding '.d.ts' file. */
// "sourceMap": true, /* Generates corresponding '.map' 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. */
"baseUrl": "./",
"esModuleInterop": true,
/* Enables emit interoperability between CommonJS and ES Modules via creation of namespace objects for all imports. Implies 'allowSyntheticDefaultImports'. */
"resolveJsonModule": true,
// "preserveSymlinks": true, /* Do not resolve the real path of symlinks. */
// "allowUmdGlobalAccess": true, /* Allow accessing UMD globals from modules. */
/* 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. */
},
"exclude": ["src/tests"]
}

40
src/skeletons/mongoose-models/User.ts
View File

@ -1,40 +0,0 @@
import path from 'path'
import { Schema, model } from 'mongoose'
export const schemaName = path.basename(__filename).split('.')[0]
const schema = new Schema(
{
username: {
type: String,
required: true
},
email: {
type: String,
required: true,
unique: true
},
password: {
type: String,
required: true
},
domains: [
{
role: Number,
domain_id: String
}
],
verification_code: {
type: Number,
length: 6
},
verified: {
type: Boolean,
default: false
}
},
{
timestamps: true
}
)
export default model(path.basename(__filename).split('.')[0], schema)

35
src/skeletons/sequelize-models/User.ts
View File

@ -1,35 +0,0 @@
import { DataTypes, Model } from 'sequelize'
import path from 'path'
import db from '../config/sequelize.config.ts'
class Instance extends Model {}
Instance.init(
{
_id: {
type: DataTypes.UUID,
primaryKey: true,
allowNull: false,
unique: true
},
username: {
type: DataTypes.STRING,
allowNull: false
},
password: {
type: DataTypes.STRING,
allowNull: false
},
email: {
type: DataTypes.STRING,
allowNull: false,
unique: true
}
},
{
sequelize: db,
tableName: path.basename(__filename).split('.')[0].toLowerCase()
}
)
export default Instance

23
src/tests/help.test.ts
View File

@ -1,23 +0,0 @@
import { assert } from 'chai'
import Help from '../help'
import pad from 'pad'
describe('should return help', () => {
it('returns all help', () => {
const help = Help.logHelp()
const correct = Help.allHelp()
assert.equal(help, correct)
})
it('returns make help', () => {
const help = Help.logHelp('make')
const correct = Help.makeHelp()
assert.equal(help, correct)
})
it('returns specific help', () => {
const help = Help.logHelp('setup')
const correct = Help.specificHelp('setup')
assert.equal(help, correct)
})
})

68
src/tests/router.test.ts
View File

@ -1,68 +0,0 @@
import { assert } from 'chai'
import Routes from '../routes'
describe('should return help', () => {
process.argv = []
it('return all help', () => {
const options = ['-h', '--help']
for (let i = 0; i < options.length; i++) {
process.argv[2] = options[i]
process.argv[3] = ''
const routes = Routes.router()
assert.equal(routes, 'all help')
}
})
it('return specific help', () => {
const options = ['-h', '--help']
for (let i = 0; i < options.length; i++) {
process.argv[2] = options[i]
process.argv[3] = 'make'
const routes = Routes.router()
assert.equal(routes, 'specific help')
}
})
})
describe('should return version', () => {
it('return version', () => {
const options = ['-v', '--version']
for (let i = 0; i < options.length; i++) {
process.argv[2] = options[i]
const routes = Routes.router()
assert.equal(routes, 'version')
}
})
})
describe('should return setup', () => {
it('return setup', () => {
process.argv[2] = 'setup'
process.argv[3] = 'test'
const routes = Routes.router()
assert.equal(routes, 'setup')
})
})
describe('should return make', () => {
const options = ['controller', 'middleware', 'route', 'service', 'model', 'view', 'test', 'interface']
for (let i = 0; i < options.length; i++) {
it(`return make ${options[i]}`, () => {
process.argv[2] = 'make'
process.argv[3] = options[i]
process.argv[4] = 'test'
const routes = Routes.router()
assert.equal(routes, `make ${options[i]}`)
})
}
})
describe('should return create', () => {
it('return create testProject', () => {
process.argv[2] = 'create'
process.argv[3] = 'testProject'
process.argv[4] = 'test'
const routes = Routes.router()
assert.equal(routes, 'create testProject')
})
})

11
src/tests/setup.test.ts
View File

@ -1,11 +0,0 @@
import { assert } from 'chai'
import Setup from '../setup'
import Global from '../global'
describe('should setup project', () => {
it('setup project', async () => {
const correct: string = Global.logSuccess()
const setup = await Setup.setup(true)
assert.equal(setup, correct)
})
})

20
src/tests/test.test.ts.old
View File

@ -1,20 +0,0 @@
import { assert } from 'chai'
import { App } from '../app'
// Describe tests
describe('some demo tests', () => {
// Create tests
it('adds two number together', () => {
assert(2 + 3 === 5)
})
it('should return Hello plus my name', () => {
assert.equal(App.sayHello('Filip'), 'Hello Filip')
assert.notEqual(App.sayHello('Adam'), 'Hello Filip')
})
it('should return Hello plus my name within instance', () => {
const app = new App('Filip')
assert.equal(app.pozdrav(), 'Hello Filip')
})
})

11
src/tests/version.test.ts
View File

@ -1,11 +0,0 @@
import { assert } from 'chai'
import Version from '../version'
import path from 'path'
describe('should return version', () => {
it('return version', () => {
const pkgJson = require(path.join(__dirname, '../../package'))
const actualVersion = pkgJson.version
assert.equal(Version.show(), `nork ${actualVersion}`)
})
})

4
src/utils/copyAssets.ts
View File

@ -1,7 +1,3 @@
import * as shell from 'shelljs' import * as shell from 'shelljs'
shell.cp('-R', 'src/skeletons', 'dist/')
shell.cp('-R', 'src/interfaces', 'dist/')
shell.cp('-R', 'src/make-files', 'dist/')
shell.chmod('+x', 'dist/app.js') shell.chmod('+x', 'dist/app.js')

10
src/version.ts
View File

@ -1,10 +0,0 @@
import fs from 'fs-extra'
import path from 'path'
export default class Version {
static show(): string {
const pkgJson = fs.readJsonSync(path.join(__dirname, '../package.json'))
const log = `nork ${pkgJson.version}`
return log
}
}