authup 1.0.0-beta.19 → 1.0.0-beta.20

package/dist/index.mjs

@@ -1,65 +1,129 @@
 #!/usr/bin/env node
-import cac from 'cac';
-import { deserializeKey, Container, EnvKey } from '@authup/config';
-import consola from 'consola';
-import { buildConfig } from '@authup/client-web-config';
-import { makeURLPublicAccessible, isObject, hasOwnProperty } from '@authup/kit';
+import { defineCommand, runMain } from 'citty';
+import fs from 'node:fs';
 import path from 'node:path';
-import { exec } from 'node:child_process';
 import process from 'node:process';
+import { makeURLPublicAccessible, extendObject, isObject, hasOwnProperty } from '@authup/kit';
+import { dycraft, defineGetter } from 'dycraft';
+import zod from 'zod';
+import { merge } from 'smob';
+import { oneOf, readInt, read } from 'envix';
+import { Container } from 'confinity';
+import consola from 'consola';
+import { exec } from 'node:child_process';
 import findUpPackagePath from 'resolve-package-path';
-import { parseConfig, buildConfig as buildConfig$1 } from '@authup/server-core';
-import readline from 'node:readline';
-import chalk from 'chalk';
 
-function isServiceValid(input) {
-    let key;
-    if (typeof input === 'string') {
-        key = deserializeKey(input);
-    } else {
-        key = input;
+function parseClientWebConfig(input = {}) {
+    const schema = zod.object({
+        port: zod.number().nonnegative().optional(),
+        host: zod.string().optional(),
+        apiUrl: zod.string().url().optional(),
+        publicUrl: zod.string().url().optional()
+    });
+    return schema.parse(input);
+}
+
+function buildClientWebConfig(raw) {
+    const config = dycraft({
+        defaults: {
+            port: 3000,
+            host: '0.0.0.0',
+            apiUrl: 'http://127.0.0.1:3001/'
+        },
+        getters: {
+            publicUrl: defineGetter((context)=>`http://${makeURLPublicAccessible(context.get('host'))}:${context.get('port')}/`)
+        }
+    });
+    return extendObject(config, parseClientWebConfig(raw));
+}
+
+function readClientWebConfigFromEnv() {
+    const config = {};
+    const port = oneOf([
+        readInt('UI_PORT'),
+        readInt('NITRO_UI_PORT'),
+        readInt('NUXT_UI_PORT'),
+        readInt('NUXT_PUBLIC_UI_PORT'),
+        readInt('PORT'),
+        readInt('NITRO_PORT'),
+        readInt('NUXT_PORT'),
+        readInt('NUXT_PUBLIC_PORT')
+    ]);
+    if (typeof port !== 'undefined') {
+        config.port = port;
+    }
+    const host = oneOf([
+        read('HOST'),
+        read('NITRO_HOST'),
+        read('NUXT_HOST')
+    ]);
+    if (host) {
+        config.host = host;
     }
-    if (key.group !== 'client' && key.group !== 'server') {
-        return false;
+    const apiUrl = oneOf([
+        read('API_URL'),
+        read('NUXT_API_URL'),
+        read('NUXT_PUBLIC_API_URL')
+    ]);
+    if (apiUrl) {
+        config.apiUrl = apiUrl;
     }
-    if (key.group === 'client') {
-        return key.name === 'web';
+    const publicURL = oneOf([
+        read('PUBLIC_URL'),
+        read('NUXT_PUBLIC_URL'),
+        read('NUXT_PUBLIC_PUBLIC_URL')
+    ]);
+    if (publicURL) {
+        config.publicUrl = publicURL;
     }
-    return key.name === 'core';
+    return config;
 }
 
-async function buildClientWebConfig(container) {
-    const client = container.getData('client/web');
-    const server = container.getData('server/core');
-    if (server) {
-        if (!client.apiUrl && typeof server.publicUrl === 'string') {
-            client.apiUrl = makeURLPublicAccessible(server.publicUrl);
+async function readClientWebConfigFromFS(options = {}) {
+    const container = new Container({
+        prefix: 'authup',
+        cwd: options.cwd
+    });
+    if (options.file) {
+        await container.loadFile(options.file);
+    } else {
+        await container.load();
+    }
+    const clientRaw = container.get('client.web') || {};
+    const serverRaw = container.get('server.core') || {};
+    if (serverRaw) {
+        if (!clientRaw.apiUrl && typeof serverRaw.publicUrl === 'string') {
+            clientRaw.apiUrl = makeURLPublicAccessible(serverRaw.publicUrl);
         }
-        if (!client.publicUrl && typeof server.authorizeRedirectUrl === 'string') {
-            client.apiUrl = makeURLPublicAccessible(server.authorizeRedirectUrl);
+        if (!clientRaw.publicUrl && typeof serverRaw.authorizeRedirectUrl === 'string') {
+            clientRaw.apiUrl = makeURLPublicAccessible(serverRaw.authorizeRedirectUrl);
         }
     }
-    return buildConfig({
-        data: client,
-        env: true
-    });
+    return clientRaw;
 }
 
-/*
- * Copyright (c) 2023.
- * Author Peter Placzek (tada5hi)
- * For the full copyright and license information,
- * view the LICENSE file that was distributed with this source code.
- */ var ServicePackageName;
-(function(ServicePackageName) {
-    ServicePackageName["CLIENT_WEB"] = "@authup/client-web";
-    ServicePackageName["SERVER_CORE"] = "@authup/server-core";
-})(ServicePackageName || (ServicePackageName = {}));
-var ServiceCommand;
-(function(ServiceCommand) {
-    ServiceCommand["START"] = "start";
-    ServiceCommand["CLEANUP"] = "cleanup";
-})(ServiceCommand || (ServiceCommand = {}));
+async function readClientWebConfigRaw(options = {}) {
+    if (options.fs && options.env) {
+        const fsOptions = boolableToObject(options.fs);
+        const fs = await readClientWebConfigFromFS(fsOptions);
+        const env = readClientWebConfigFromEnv();
+        return merge(env, fs);
+    }
+    if (options.fs) {
+        const fsOptions = boolableToObject(options.fs);
+        return readClientWebConfigFromFS(fsOptions);
+    }
+    if (options.env) {
+        return readClientWebConfigFromEnv();
+    }
+    return {};
+}
+function boolableToObject(input) {
+    if (typeof input === 'boolean') {
+        return {};
+    }
+    return input;
+}
 
 /*
  * Copyright (c) 2022.
@@ -109,15 +173,13 @@ function parseProcessOutputData(input) {
     return parts.join(' ');
 }
 
-async function execShellCommand(ctx) {
-    ctx.env = ctx.env || {};
-    ctx.args = ctx.args || {};
+async function execShellCommand(command, ctx = {}) {
     return new Promise((resolve, reject)=>{
-        const childProcess = exec(`${ctx.command} ${stringifyObjectArgs(ctx.args)}`, {
+        const childProcess = exec(`${command} ${stringifyObjectArgs(ctx.args || {})}`, {
             env: {
                 PATH: process.env.PATH,
                 ...ctx.envFromProcess ? process.env : {},
-                ...ctx.env
+                ...ctx.env ? ctx.env : {}
             }
         });
         childProcess.on('error', (data)=>{
@@ -163,253 +225,212 @@ function findModulePath(module) {
     return modulePath;
 }
 
-function extendEnv(input) {
-    const env = {};
-    const keys = Object.keys(input);
-    for(let i = 0; i < keys.length; i++){
-        env[keys[i]] = input[keys[i]];
-        if (!keys[i].match(/^(?:NUXT|NITRO)_.*$/)) {
-            env[`NUXT_PUBLIC_${keys[i]}`] = input[keys[i]];
-        }
-    }
-    return env;
-}
-function buildWebAppExecutionContext(ctx) {
-    if (ctx.command !== ServiceCommand.START) {
-        throw new Error(`The command ${ctx.command} is not supported`);
-    }
-    const env = ctx.env || {};
-    const data = ctx.container.getData('client/web');
-    const config = buildConfig({
-        data,
-        env: true
-    });
-    if (config.host) {
-        env.HOST = config.host;
-    }
-    if (config.port) {
-        env.PORT = `${config.port}`;
-    }
-    if (config.apiUrl) {
-        env.API_URL = config.apiUrl;
-    }
-    if (config.publicUrl) {
-        env.PUBLIC_URL = config.publicUrl;
-    }
-    let command;
-    const modulePath = findModulePath(ServicePackageName.CLIENT_WEB);
-    if (typeof modulePath === 'string') {
-        const directory = path.dirname(modulePath);
-        const outputPath = path.join(directory, '.output', 'server', 'index.mjs');
-        command = `node ${outputPath}`;
-    } else {
-        command = `npx ${ServicePackageName.CLIENT_WEB}`;
-    }
-    return {
-        ...ctx,
-        command,
-        env: extendEnv(env)
-    };
-}
-
-async function buildServerCoreConfig(container) {
-    const data = parseConfig(container.getData('server/core'));
-    return buildConfig$1({
-        data,
-        env: true
-    });
-}
+/*
+ * Copyright (c) 2023.
+ * Author Peter Placzek (tada5hi)
+ * For the full copyright and license information,
+ * view the LICENSE file that was distributed with this source code.
+ */ var PackageName;
+(function(PackageName) {
+    PackageName["CLIENT_WEB"] = "@authup/client-web";
+    PackageName["SERVER_CORE"] = "@authup/server-core";
+})(PackageName || (PackageName = {}));
+var PackageID;
+(function(PackageID) {
+    PackageID["CLIENT_WEB"] = "client.web";
+    PackageID["SERVER_CORE"] = "server.core";
+})(PackageID || (PackageID = {}));
+var PackageCommand;
+(function(PackageCommand) {
+    PackageCommand["START"] = "start";
+    PackageCommand["CLEANUP"] = "cleanup";
+})(PackageCommand || (PackageCommand = {}));
 
-function buildServerCoreExecutionContext(ctx) {
-    let command;
-    const modulePath = findModulePath(ServicePackageName.SERVER_CORE);
-    if (typeof modulePath === 'string') {
-        const directory = path.dirname(modulePath);
-        const outputPath = path.join(directory, 'dist', 'cli', 'index.js');
-        command = `node ${outputPath}`;
-    } else {
-        command = `npx ${ServicePackageName.SERVER_CORE}`;
-    }
-    switch(ctx.command){
-        case ServiceCommand.START:
-            {
-                command += ' start';
-                break;
-            }
-        case ServiceCommand.CLEANUP:
-            {
-                command += ' reset';
-                break;
-            }
-        default:
-            {
-                throw new Error(`The command ${ctx.command} is not supported.`);
+class ClientWebPackage {
+    async execute(command, options = {}) {
+        const shellCommand = await this.buildShellCommand();
+        const env = await this.buildEnv({
+            configDirectory: options.configDirectory,
+            configFile: options.configFile
+        });
+        return execShellCommand(shellCommand, {
+            env,
+            logDataStream (line) {
+                consola.info(`${PackageID.CLIENT_WEB}: ${line}`);
+            },
+            logErrorStream (line) {
+                consola.warn(`${PackageID.CLIENT_WEB}: ${line}`);
             }
-    }
-    return {
-        ...ctx,
-        command
-    };
-}
-
-function buildInfoCommand(cac) {
-    cac.command('info', 'Get information about the configuration.').option('-c, --config [config]', 'Specify a configuration file').action(async (ctx)=>{
-        const container = new Container({
-            prefix: 'authup',
-            keys: [
-                'client/web',
-                'server/core'
-            ]
         });
-        if (ctx.config) {
-            await container.loadFromFilePath(ctx.config);
+    }
+    async buildShellCommand() {
+        let shellCommand;
+        const modulePath = findModulePath(PackageName.CLIENT_WEB);
+        if (typeof modulePath === 'string') {
+            const directory = path.dirname(modulePath);
+            const outputPath = path.join(directory, '.output', 'server', 'index.mjs');
+            shellCommand = `node ${outputPath}`;
         } else {
-            await container.load();
+            shellCommand = `npx ${PackageName.CLIENT_WEB}`;
         }
-        const clientWeb = await buildClientWebConfig(container);
-        consola.info(`Host: ${clientWeb.host}`);
-        consola.info(`Port: ${clientWeb.port}`);
-        consola.info('------------');
-        const serverCore = await buildServerCoreConfig(container);
-        consola.info(`Host: ${serverCore.host}`);
-        consola.info(`Port: ${serverCore.port}`);
-        consola.info(`Environment: ${serverCore.env}`);
-        consola.info(`RootPath: ${serverCore.rootPath}`);
-        consola.info(`WritableDirectoryPath: ${serverCore.writableDirectoryPath}`);
-        consola.info('------------');
-        consola.info('Report an issue: https://github.com/authup/authup/issues/new');
-        consola.info('Suggest an improvement: https://github.com/authup/authup/discussions/new');
-        consola.info('Read documentation: https://authup.org');
-    });
-}
-
-async function executeServiceCommand(context) {
-    let service;
-    if (typeof context.service === 'string') {
-        service = deserializeKey(context.service);
-    } else {
-        service = context.service;
+        return shellCommand;
     }
-    const env = {};
-    const config = context.container.get(`${service.group}/${service.name}`);
-    if (config) {
-        const paths = config.paths.join(',');
-        if (paths.length > 0) {
-            env[EnvKey.CONFIG_FILE] = paths;
+    async buildEnv(ctx) {
+        const env = {};
+        const configRaw = await readClientWebConfigRaw({
+            fs: {
+                file: ctx.configFile,
+                cwd: ctx.configDirectory
+            }
+        });
+        const config = buildClientWebConfig(configRaw);
+        if (config.host) {
+            env.HOST = config.host;
         }
-    }
-    let shellExecContext;
-    try {
-        if (service.group === 'server' && service.name === 'core') {
-            shellExecContext = buildServerCoreExecutionContext({
-                command: context.command,
-                env
-            });
+        if (config.port) {
+            env.PORT = `${config.port}`;
         }
-        if (service.group === 'client' && service.name === 'web') {
-            shellExecContext = buildWebAppExecutionContext({
-                container: context.container,
-                command: context.command,
-                env
-            });
+        if (config.apiUrl) {
+            env.API_URL = config.apiUrl;
         }
-    } catch (e) {
-        consola.error(`${service.group}/${service.name}: The service command ${context.command} not supported.`);
-        process.exit(1);
-    }
-    if (!shellExecContext) {
-        consola.error(`${service.group}/${service.name}: The service is not supported.`);
-        process.exit(1);
+        if (config.publicUrl) {
+            env.PUBLIC_URL = config.publicUrl;
+        }
+        return this.extendEnvKeys(env);
     }
-    return execShellCommand({
-        ...shellExecContext,
-        logDataStream (line) {
-            consola.info(`${service.group}/${service.name}: ${line}`);
-        },
-        logErrorStream (line) {
-            consola.warn(`${service.group}/${service.name}: ${line}`);
+    extendEnvKeys(input) {
+        const env = {};
+        const keys = Object.keys(input);
+        for(let i = 0; i < keys.length; i++){
+            env[keys[i]] = input[keys[i]];
+            if (!keys[i].match(/^(?:NUXT|NITRO)_.*$/)) {
+                env[`NUXT_PUBLIC_${keys[i]}`] = input[keys[i]];
+            }
         }
-    });
+        return env;
+    }
 }
-async function executeServicesCommand(context) {
-    const container = new Container({
-        prefix: 'authup',
-        keys: context.servicesAllowed || context.services
-    });
-    if (context.config) {
-        await container.loadFromFilePath(context.config);
-    } else {
-        await container.load();
+
+class ServerCorePackage {
+    async execute(command, options = {}) {
+        const shellCommand = await this.buildShellCommand(command, {
+            configDirectory: options.configDirectory,
+            configFile: options.configFile
+        });
+        return execShellCommand(shellCommand, {
+            logDataStream (line) {
+                consola.info(`${PackageID.SERVER_CORE}: ${line}`);
+            },
+            logErrorStream (line) {
+                consola.warn(`${PackageID.SERVER_CORE}: ${line}`);
+            }
+        });
     }
-    const promises = [];
-    for(let i = 0; i < context.services.length; i++){
-        const service = deserializeKey(context.services[i]);
-        if (!isServiceValid(service)) {
-            consola.error(`${chalk.red(`${service.group}/${service.name}`)}: The service does not exist.`);
-            process.exit(1);
+    async buildShellCommand(command, options) {
+        const parts = [];
+        const modulePath = findModulePath(PackageName.SERVER_CORE);
+        if (typeof modulePath === 'string') {
+            const directory = path.dirname(modulePath);
+            const outputPath = path.join(directory, 'dist', 'cli', 'index.js');
+            parts.push(`node ${outputPath}`);
+        } else {
+            parts.push(`npx ${PackageName.SERVER_CORE}`);
         }
-        if (context.servicesAllowed && context.servicesAllowed.indexOf(`${service.group}/${service.name}`) === -1) {
-            consola.error(`${chalk.red(`${service.group}/${service.name}`)}: The service does not support the ${context.command} command.`);
-            process.exit(1);
+        parts.push(command);
+        if (options.configFile) {
+            parts.push(`--configFile=${options.configFile}`);
         }
-        promises.push(executeServiceCommand({
-            command: context.command,
-            service,
-            container
-        }));
-    }
-    const childProcesses = await Promise.all(promises);
-    const readLine = readline.createInterface({
-        input: process.stdin,
-        output: process.stdout
-    });
-    readLine.on('SIGINT', ()=>{
-        for(let i = 0; i < childProcesses.length; i++){
-            childProcesses[i].kill();
+        if (options.configDirectory) {
+            parts.push(`--configDirectory=${options.configDirectory}`);
         }
-        process.exit();
-    });
+        return parts.join(' ');
+    }
 }
 
-function buildCleanupCommand(cac) {
-    cac.command('cleanup [...services]', 'Cleanup a service').option('-c, --config [config]', 'Specify a configuration file').action(async (keysInput, ctx)=>{
-        const servicesAllowed = [
-            'server/core'
-        ];
-        if (!keysInput || keysInput.length === 0) {
-            keysInput = servicesAllowed;
-        }
-        await executeServicesCommand({
-            config: ctx.config,
-            command: ServiceCommand.CLEANUP,
-            services: keysInput,
-            servicesAllowed
-        });
-    });
+async function executePackageCommand(pkg, command, options = {}) {
+    switch(pkg){
+        case PackageID.CLIENT_WEB:
+            {
+                const serverCore = new ClientWebPackage();
+                return serverCore.execute(command, options);
+            }
+        case PackageID.SERVER_CORE:
+            {
+                const serverCore = new ServerCorePackage();
+                return serverCore.execute(command, options);
+            }
+    }
+    throw new Error(`The package ${pkg} is not supported.`);
 }
 
-function buildStartCommand(cac) {
-    cac.command('start [...services]', 'Start a service').option('-c, --config [config]', 'Specify a configuration file').action(async (keysInput, ctx)=>{
-        const servicesAllowed = [
-            'client/web',
-            'server/core'
-        ];
-        if (!keysInput || keysInput.length === 0) {
-            keysInput = servicesAllowed;
+function normalizePackageID(input) {
+    const value = input.trim().toLowerCase();
+    switch(value){
+        case 'client.web':
+        case 'client/web':
+        case 'client-web':
+            {
+                return PackageID.CLIENT_WEB;
+            }
+        case 'server.core':
+        case 'server/core':
+        case 'server-core':
+            {
+                return PackageID.SERVER_CORE;
+            }
+    }
+    return undefined;
+}
+
+async function createCLIEntryPointCommand() {
+    const pkgRaw = await fs.promises.readFile(path.join(process.cwd(), 'package.json'), {
+        encoding: 'utf8'
+    });
+    const pkg = JSON.parse(pkgRaw);
+    return defineCommand({
+        meta: {
+            name: pkg.name,
+            version: pkg.version,
+            description: pkg.description
+        },
+        args: {
+            command: {
+                type: 'positional',
+                description: 'The command which should be forwarded to the package.'
+            },
+            package: {
+                type: 'positional',
+                description: 'The package, which should be targeted.',
+                required: false
+            },
+            configDirectory: {
+                type: 'string',
+                description: 'Config directory path',
+                alias: 'cD'
+            },
+            configFile: {
+                type: 'string',
+                description: 'Name of one or more configuration files.',
+                alias: 'cF'
+            }
+        },
+        async run (ctx) {
+            let pkgs = ctx.args.package ? ctx.args.package.split(',') : [];
+            pkgs = pkgs.map((pkg)=>normalizePackageID(pkg)).filter((pkg)=>Boolean(pkg));
+            if (pkgs.length === 0) {
+                pkgs = Object.values(PackageID);
+            }
+            const promises = [];
+            for(let i = 0; i < pkgs.length; i++){
+                promises.push(executePackageCommand(pkgs[i], ctx.args.command, {
+                    configFile: ctx.args.configFile,
+                    configDirectory: ctx.args.configDirectory
+                }));
+            }
+            await Promise.all(promises);
         }
-        await executeServicesCommand({
-            config: ctx.config,
-            command: ServiceCommand.START,
-            services: keysInput,
-            servicesAllowed
-        });
     });
 }
 
-const cli = cac();
-buildInfoCommand(cli);
-buildStartCommand(cli);
-buildCleanupCommand(cli);
-cli.help();
-cli.parse();
+Promise.resolve().then(()=>createCLIEntryPointCommand()).then((command)=>runMain(command));
 //# sourceMappingURL=index.mjs.map