create-lupine 1.0.0

package/index.js

@@ -0,0 +1,277 @@
+#!/usr/bin/env node
+
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import crypto from 'node:crypto';
+
+function generateRandomString(length) {
+  const chars = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz_!@&?-#$';
+  return [...crypto.randomBytes(length)].map((x) => chars[x % chars.length]).join('');
+}
+
+const red = (str) => `\x1b[31m${str}\x1b[0m`;
+const green = (str) => `\x1b[32m${str}\x1b[0m`;
+const bold = (str) => `\x1b[1m${str}\x1b[0m`;
+
+const argv = process.argv.slice(2).reduce(
+  (acc, arg) => {
+    if (arg.startsWith('--template=')) {
+      acc.template = arg.split('=')[1];
+    } else if (arg.startsWith('--')) {
+      acc[arg.slice(2)] = true;
+    } else {
+      acc._.push(arg);
+    }
+    return acc;
+  },
+  { _: [] }
+);
+// Handle -t alias manually if needed, or just support --template
+// The original code supported `argv.t`
+const args = process.argv.slice(2);
+for (let i = 0; i < args.length; i++) {
+  if (args[i] === '-t' && args[i + 1]) {
+    argv.template = args[i + 1];
+  }
+}
+const cwd = process.cwd();
+
+const TEMPLATES = [
+  {
+    name: 'hello-world',
+    display: 'Hello World',
+    itemType: 'frontend',
+    color: green,
+  },
+  {
+    name: 'doc-starter',
+    display: 'Documentation Starter',
+    itemType: 'frontend',
+    color: green,
+    needsPress: true,
+  },
+];
+
+const renameFiles = {
+  _gitignore: '.gitignore',
+};
+
+async function init() {
+  let targetDir = argv._[0];
+  let template = argv.template || argv.t;
+
+  const defaultTargetDir = 'lupine-project';
+
+  function isValidPackageName(projectName) {
+    return /^(?:@[a-z0-9-*~][a-z0-9-*._~]*\/)?[a-z0-9-~][a-z0-9-._~]*$/.test(projectName);
+  }
+
+  function toValidPackageName(projectName) {
+    return projectName
+      .trim()
+      .toLowerCase()
+      .replace(/\s+/g, '-')
+      .replace(/^[._]/, '')
+      .replace(/[^a-z0-9-~]+/g, '-');
+  }
+
+  if (!targetDir) {
+    targetDir = (await prompt(`Project name: (${green(defaultTargetDir)}) `)) || defaultTargetDir;
+  }
+
+  while (!isValidPackageName(targetDir)) {
+    console.log(red(`✖ Invalid project name: "${targetDir}". Name can not contain spaces or sensitive characters.`));
+    const suggestion = toValidPackageName(targetDir);
+    targetDir = (await prompt(`Project name: (${green(suggestion)}) `)) || suggestion;
+  }
+
+  const root = path.join(cwd, targetDir);
+
+  if (fs.existsSync(root) && !isEmpty(root)) {
+    const overwrite = await prompt(
+      `Target directory "${green(targetDir)}" is not empty. Remove existing files and continue? (y/N) `
+    );
+    if (overwrite.toLowerCase() !== 'y') {
+      throw new Error(red('✖ Operation cancelled'));
+    }
+    emptyDir(root);
+  } else if (!fs.existsSync(root)) {
+    fs.mkdirSync(root, { recursive: true });
+  }
+
+  if (!template || !TEMPLATES.find((t) => t.name === template)) {
+    if (template && !TEMPLATES.find((t) => t.name === template)) {
+      console.log(`"${template}" isn't a valid template. Please choose from below:`);
+    } else {
+      console.log('Select a template:');
+    }
+
+    TEMPLATES.forEach((t, i) => {
+      console.log(`  ${t.color(i + 1 + '. ' + (t.display || t.name))}`);
+    });
+
+    const templateIdx = await prompt(`Select a template (${green('1-' + TEMPLATES.length)}): `);
+    const selected = TEMPLATES[parseInt(templateIdx) - 1];
+    if (!selected) {
+      throw new Error(red('✖ Invalid template selected'));
+    }
+    template = selected.name;
+  }
+
+  const templateDir = path.resolve(fileURLToPath(import.meta.url), '../templates', template);
+  const commonDir = path.resolve(fileURLToPath(import.meta.url), '../templates', 'common');
+
+  // ... (copy logic remains same)
+
+  console.log(`\nScaffolding project in ${root}...`);
+
+  copyDir(commonDir, root);
+
+  const appsDir = path.join(root, 'apps');
+  if (!fs.existsSync(appsDir)) {
+    fs.mkdirSync(appsDir);
+  }
+
+  const appName = path.basename(root);
+  const targetAppDir = path.join(appsDir, appName);
+
+  copyDir(templateDir, targetAppDir);
+
+  const lupineJsonPath = path.join(targetAppDir, 'lupine.json');
+  if (fs.existsSync(lupineJsonPath)) {
+    const lupineJson = JSON.parse(fs.readFileSync(lupineJsonPath, 'utf-8'));
+    lupineJson.name = appName;
+    fs.writeFileSync(lupineJsonPath, JSON.stringify(lupineJson, null, 2));
+  }
+
+  const pkg = {
+    name: appName,
+    version: '0.0.0',
+    private: true,
+    workspaces: ['apps/*', 'apps/*/*', 'packages/*'],
+    scripts: {
+      'app1:build-win': `electron-builder --win --config apps/${appName}/electron/builder.json`,
+      'app1:build-linux': `electron-builder --linux --config apps/${appName}/electron/builder.json`,
+      'app1:build-mac': `export CSC_IDENTITY_AUTO_DISCOVERY=true && electron-builder --mac --x64 --config apps/${appName}/electron/builder.json`,
+      'app1:unpack-mac': `npx asar extract dist/build/mac-arm64-unpacked/${appName}.app/Contents/Resources/app.asar dist/build/mac-arm64-unpacked/${appName}.app/Contents/Resources/app.asar-unpack`,
+      'app1:unpack-linux': `npx asar extract dist/build/linux-arm64-unpacked/resources/app.asar dist/build/linux-arm64-unpacked/resources/app.asar-unpack`,
+      'app1:unpack-win': `npx asar extract dist/build/win-unpacked/resources/app.asar dist/build/win-unpacked/resources/app.asar-unpack`,
+      'app1:desktop': `electron apps/${appName}/electron/main.js`,
+      'app1:sync': `npm run sync --workspace=${appName}-web`,
+      'app1:open-ios': `npm run open-ios --workspace=${appName}-web`,
+      'app1:open-android': `npm run open-android --workspace=${appName}-web`,
+      dev: 'node ./dev/dev-watch --env=.env.development --dev=1 --cmd=start-dev',
+      build: 'node ./dev/dev-watch --env=.env.production --dev=0',
+      'build-mobile': 'node ./dev/dev-watch --env=.env.mobile --dev=0 --mobile=1',
+      'start-dev': 'node dist/server_root/server/app-loader.js --env=.env.development',
+      'start-production': 'node dist/server_root/server/app-loader.js --env=.env.production',
+      format: 'prettier --write "**/*.{js,json,css,scss,md,html,yaml,ts,jsx,tsx}"',
+    },
+    dependencies: {
+      'lupine.api': 'file:packages/lupine.api',
+    },
+    devDependencies: {
+      esbuild: '^0.24.2',
+      electron: '^35.2.0',
+      'electron-builder': '^26.0.12',
+      typescript: '^5.7.2',
+      '@types/node': '^22.10.5',
+      prettier: '^2.7.1',
+    },
+  };
+
+  pkg.dependencies = {
+    'lupine.api': '^1.0.1',
+    'lupine.components': '^1.0.1',
+    'lupine.web': '^1.0.1',
+  };
+
+  const templateObj = TEMPLATES.find((t) => t.name === template);
+  if (templateObj && templateObj.needsPress) {
+    pkg.dependencies['lupine.press'] = '^1.0.1';
+  }
+
+  fs.writeFileSync(path.join(root, 'package.json'), JSON.stringify(pkg, null, 2));
+
+  const gitignorePath = path.join(root, '_gitignore');
+  if (fs.existsSync(gitignorePath)) {
+    fs.renameSync(gitignorePath, path.join(root, '.gitignore'));
+  }
+
+  if (fs.existsSync(path.join(root, '.env'))) {
+    let envContent = fs.readFileSync(path.join(root, '.env'), 'utf-8');
+
+    // Auto-generate passwords
+    const keysToUpdate = ['ADMIN_PASS=', 'CRYPTO_KEY=', 'DEV_ADMIN_PASS=', 'DEV_CRYPTO_KEY='];
+    keysToUpdate.forEach((key) => {
+      // Replace line starting with key=
+      envContent = envContent.replace(new RegExp(`^${key}.*`, 'gm'), `${key}${generateRandomString(32)}`);
+    });
+
+    envContent = envContent.replace(/{APP-NAME}/g, appName);
+    fs.writeFileSync(path.join(root, '.env'), envContent);
+  }
+
+  console.log(`\nDone. Now run:\n`);
+  console.log(`  cd ${targetDir}`);
+  console.log(`  npm install`);
+  console.log(`  npm run dev`);
+  console.log(``);
+}
+
+import readline from 'node:readline';
+
+function prompt(question) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+
+function copy(src, dest) {
+  const stat = fs.statSync(src);
+  if (stat.isDirectory()) {
+    copyDir(src, dest);
+  } else {
+    fs.copyFileSync(src, dest);
+  }
+}
+
+function copyDir(srcDir, destDir) {
+  fs.mkdirSync(destDir, { recursive: true });
+  for (const file of fs.readdirSync(srcDir)) {
+    const srcFile = path.resolve(srcDir, file);
+    const destFile = path.resolve(destDir, file);
+    copy(srcFile, destFile);
+  }
+}
+
+function isEmpty(path) {
+  const files = fs.readdirSync(path);
+  return files.length === 0 || (files.length === 1 && files[0] === '.git');
+}
+
+function emptyDir(dir) {
+  if (!fs.existsSync(dir)) {
+    return;
+  }
+  for (const file of fs.readdirSync(dir)) {
+    const abs = path.resolve(dir, file);
+    if (file === '.git') {
+      continue;
+    }
+    fs.rmSync(abs, { recursive: true, force: true });
+  }
+}
+
+init().catch((e) => {
+  console.error(e.message);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "create-lupine",
+  "version": "1.0.0",
+  "description": "Scaffolding tool for Lupine.js projects",
+  "bin": {
+    "create-lupine": "index.js"
+  },
+  "files": [
+    "index.js",
+    "templates"
+  ],
+  "scripts": {
+    "npm-publish": "npm publish --access public",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "dependencies": {},
+  "type": "module"
+}

package/templates/common/.env

@@ -0,0 +1,57 @@
+# start with WEB. will be exposed to the frontend file
+WEB.API_PORT=11080
+WEB.API_BASE_URL=
+
+# start with “app_name.” will be assigned to the individual app's env object
+# demo.app.WEB.test2=11aa
+# demo.app.test2=11aa
+
+# used by Server Side Renderring for fetch (can't be localhost)
+API_BASE_URL=http://127.0.0.1:11080
+HTTP_PORT=11080
+HTTPS_PORT=11083
+#'127.0.0.1' or for all ips: "::"
+BIND_IP=0.0.0.0
+
+NODE_TLS_REJECT_UNAUTHORIZED=0
+
+LOG_FOLDER=./dist/log
+LOG_FILENAME=log-%index%.log
+# size can be ?kb or ?mb
+LOG_MAX_SIZE=1mb
+LOG_MAX_COUNT=5
+LOG_OUT_TO_FILE=true
+LOG_OUT_TO_CONSOLE=true
+
+# use following command to generate random keys
+#node -e "console.log(require('node:crypto').randomBytes(32).toString('hex'))"
+# use following command to generate more complex strings
+#node -e "l=32;c='0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz_!@&?-#$';console.log([...require('node:crypto').randomBytes(l)].map(x => c[x%c.length]).join(''))"
+
+# server path for web (appName_web), server (server) and data (appName_data)
+SERVER_ROOT_PATH=dist/server_root
+ADMIN_USER=admin
+ADMIN_PASS=
+CRYPTO_KEY=
+
+# for development
+DEV_ADMIN_USER=admin
+DEV_ADMIN_PASS=
+DEV_CRYPTO_KEY=
+
+# define apps on the same port with different domains (locally or on a real server)
+# in local, the domains should be added to the /etc/hosts (or C:\Windows\System32\drivers\etc\hosts) file
+APPS={APP-NAME}
+# below is empty that means all domains will come to this app
+DOMAINS:{APP-NAME}=
+
+# Https Keys and Crts are for domains (not apps), use following command to generate
+# mkcert example.com "*.example.com" localhost 127.0.0.1 ::1
+SSL_KEY_PATH=dev/example.com+4-key.pem
+SSL_CRT_PATH=dev/example.com+4.pem
+HTTPS_KEY_PATH:{APP-NAME}=dev/example.com+4-key.pem
+HTTPS_CRT_PATH:{APP-NAME}=dev/example.com+4.pem
+
+DB_TYPE=sqlite
+DB_FILENAME=sqlite3.db
+DB_TYPE:{APP-NAME}=sqlite

package/templates/common/.env.development

@@ -0,0 +1,7 @@
+# dev is used when run dev
+# starting with WEB. will be exposed to env.web.ts file
+
+#!import .env
+WEB.NODE_ENV=development
+NODE_ENV=development
+LOG_LEVEL=debug

package/templates/common/.env.mobile

@@ -0,0 +1,10 @@
+# production is used when run prod
+# starting with WEB. will be exposed to the FrontEnd
+
+#!import .env
+WEB.NODE_ENV=production
+NODE_ENV=production
+LOG_LEVEL=info
+
+WEB.API_BASE_URL=https://your-server/
+WEB.API_PORT=80

package/templates/common/.env.production

@@ -0,0 +1,7 @@
+# production is used when run prod
+# starting with WEB. will be exposed to the FrontEnd
+
+#!import .env
+WEB.NODE_ENV=production
+NODE_ENV=production
+LOG_LEVEL=info

package/templates/common/apps/server/src/app-loader.ts

@@ -0,0 +1,41 @@
+import { fork, ChildProcess } from 'child_process';
+import path from 'path';
+
+let app: ChildProcess | null = null;
+const startApp = () => {
+  console.log('Loader: starting app...');
+  app = fork(path.join(__dirname, './index.js'), [], {
+    env: { ...process.env, FROM_LOADER: '1' },
+  });
+
+  // child->parent
+  app.on('message', async (msg: any) => {
+    if (msg?.id === 'debug' && msg?.message === 'restartApp') {
+      console.log('Loader: app requested restart.');
+      await restartApp();
+    }
+  });
+
+  // child exit
+  app.on('exit', (code) => {
+    console.log('Loader: app exited with code', code);
+  });
+};
+
+const restartApp = async () => {
+  if (!app) return;
+
+  return new Promise<void>((resolve) => {
+    console.log('Loader: sending shutdown to app...');
+    app!.send({ id: 'debug', message: 'shutdown' });
+
+    // wait for app.ts to exit
+    app!.once('exit', () => {
+      console.log('Loader: app fully exited, restarting...');
+      startApp();
+      resolve();
+    });
+  });
+};
+
+startApp();

package/templates/common/apps/server/src/fetch-data.ts

@@ -0,0 +1,20 @@
+import { JsonObject } from 'lupine.api';
+
+export const fetchData = async (urlWithoutHost: string, postData: string | JsonObject) => {
+  const url = process.env['API_BASE_URL'] + urlWithoutHost;
+  console.log('========fetchData', url);
+
+  const option = {
+    method: postData ? 'POST' : 'GET',
+    body: postData ? (typeof postData === 'string' ? postData : JSON.stringify(postData)) : undefined,
+  };
+  const data = await fetch(url, option);
+  // const json = await data.json();
+  const text = await data.text();
+  try {
+    const json = JSON.parse(text);
+    return { json };
+  } catch (e) {
+    return { text };
+  }
+};

package/templates/common/apps/server/src/index.ts

@@ -0,0 +1,66 @@
+// initApp should be called before any other logics, so need to avoid `export default new Class()`
+import * as path from 'path';
+import {
+  HostToPathProps,
+  appStart,
+  bindRenderPageFunctions,
+  getDefaultDbConfig,
+  getRenderPageFunctions,
+  loadEnv,
+} from 'lupine.api';
+import { fetchData } from './fetch-data';
+import { ServerEnvKeys } from './server-env-keys';
+
+const initAndStartServer = async () => {
+  const envFile = process.argv.find((i) => i.startsWith('--env='))?.substring(6) || '.env';
+  // it can use "#!import file_name" to import another env file
+  await loadEnv(envFile);
+  bindRenderPageFunctions({ fetchData });
+
+  const dbConfig = { ...getDefaultDbConfig() };
+  const serverRootPath = path.resolve(process.env[ServerEnvKeys.SERVER_ROOT_PATH]!);
+  const apps = (process.env[ServerEnvKeys.APPS] || '').split(',');
+  const webRootMap: HostToPathProps[] = [];
+
+  for (const app of apps) {
+    const appHosts = process.env[`${ServerEnvKeys.DOMAINS}@${app}`] || '';
+    const dbFilename =
+      process.env[`${ServerEnvKeys.DB_FILENAME}@${app}`] || process.env[`${ServerEnvKeys.DB_FILENAME}`] || 'sqlite3.db';
+    webRootMap.push({
+      appName: app,
+      hosts: appHosts ? appHosts.split(',') : [],
+      // web, data, api folders should be created in building process
+      webPath: path.join(serverRootPath, app + '_web'),
+      dataPath: path.join(serverRootPath, app + '_data'),
+      apiPath: path.join(serverRootPath, app + '_api'),
+      dbType: process.env[`${ServerEnvKeys.DB_TYPE}@${app}`] || process.env[`${ServerEnvKeys.DB_TYPE}`] || 'sqlite',
+      dbConfig: { ...dbConfig, filename: dbFilename },
+    });
+  }
+
+  const bindIp = process.env[ServerEnvKeys.BIND_IP] || '::';
+  // 0 to disable http/https server
+  const httpPort = Number.parseInt(process.env[ServerEnvKeys.HTTP_PORT] || '8080');
+  const httpsPort = Number.parseInt(process.env[ServerEnvKeys.HTTPS_PORT] || '8443');
+  const sslKeyPath = process.env[ServerEnvKeys.SSL_KEY_PATH] || '';
+  const sslCrtPath = process.env[ServerEnvKeys.SSL_CRT_PATH] || '';
+
+  // Can't use log until initApp is called (after AppStart.start)
+  await appStart.start({
+    debug: process.env[ServerEnvKeys.NODE_ENV] === 'development',
+    appEnvFile: envFile,
+    renderPageFunctions: getRenderPageFunctions(),
+    apiConfig: {
+      serverRoot: `${serverRootPath}`,
+      webHostMap: webRootMap,
+    },
+    serverConfig: {
+      bindIp,
+      httpPort,
+      httpsPort,
+      sslKeyPath,
+      sslCrtPath,
+    },
+  });
+};
+initAndStartServer();

package/templates/common/apps/server/src/server-env-keys.ts

@@ -0,0 +1,22 @@
+// some like APPS, HTTP_PORT, SERVER_ROOT_PATH are also used in 'dev-watch.js'
+export const enum ServerEnvKeys {
+  BIND_IP = 'BIND_IP',
+  HTTP_PORT = 'HTTP_PORT',
+  HTTPS_PORT = 'HTTPS_PORT',
+  SSL_KEY_PATH = 'SSL_KEY_PATH',
+  SSL_CRT_PATH = 'SSL_CRT_PATH',
+  WEB_ROOT_MAP = 'WEB_ROOT_MAP',
+  SERVER_ROOT_PATH = 'SERVER_ROOT_PATH',
+  NODE_ENV = 'NODE_ENV',
+  APPS = 'APPS',
+  DOMAINS = 'DOMAINS',
+  DB_TYPE = 'DB_TYPE',
+  DB_FILENAME = 'DB_FILENAME',
+  LOG_FOLDER = 'LOG_FOLDER',
+  LOG_FILENAME = 'LOG_FILENAME',
+  LOG_MAX_SIZE = 'LOG_MAX_SIZE',
+  LOG_MAX_COUNT = 'LOG_MAX_COUNT',
+  LOG_OUT_TO_FILE = 'LOG_OUT_TO_FILE',
+  LOG_OUT_TO_CONSOLE = 'LOG_OUT_TO_CONSOLE',
+  LOG_LEVEL = 'LOG_LEVEL',
+}