@fluixi/cli 0.1.0-alpha.82 → 0.1.0-alpha.83

package/dist/generate.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"generate.d.ts","sourceRoot":"","sources":["../src/generate.ts"],"names":[],"mappings":"AAyMA,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,EAAE,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,CAmCjF"}
+{"version":3,"file":"generate.d.ts","sourceRoot":"","sources":["../src/generate.ts"],"names":[],"mappings":"AA8MA,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,EAAE,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,CAgGjF"}

package/dist/generate.js

@@ -4,18 +4,32 @@
  *   fluixi g route about             → src/routes/about.tsx  (a file route)
  *   fluixi g route blog/[id]         → src/routes/blog/[id].tsx
  *   fluixi g middleware              → src/middleware.ts
+ *   fluixi g service Orders          → src/services/orders.ts, listed in src/app.config.ts
+ *   fluixi g auth oauth2             → env config, auth service, callback and login routes
  */
 import { writeFileSync, readFileSync, existsSync, mkdirSync } from 'node:fs';
 import { resolve, dirname, relative, basename } from 'node:path';
 import { c } from '@fluixi/start/ui';
-const GEN_USAGE = `Usage: fluixi generate <kind> <name>
+import { envPublicNames, ensureAuthEnv, registerModule, ScaffoldError, setupBetterAuth, setupOAuth2, templates as t, writeOnce as writeOnceTo, importPath, } from './scaffold/index.js';
+import { report, reportAuth } from './report.js';
+const GEN_USAGE = `Usage: fluixi generate <kind> [name] [options]
 
 Kinds:
-  component <Name>      a reusable component        → src/components/<Name>.{tsx,ts}
-  route <path>          a file-based route page     → src/routes/<path>.{tsx,ts}
-  middleware            the request middleware file → src/middleware.ts
-  auth                  @fluixi/auth wiring         → auth.config + auth.client + middleware + /api/auth route
+  component <Name>            a reusable component         → src/components/<Name>.{tsx,ts}
+  route <path>                a file-based route page      → src/routes/<path>.{tsx,ts}
+  middleware                  the request middleware file  → src/middleware.ts
+  env                         typed config from env.public → src/config/env.ts
+  module <name>               an app module                → src/services/<name>/<name>.module.ts
+  service <Name> [--server]   a service, token and module  → src/services/<name>.ts (.server.ts)
+  api <path> [--role <role>]  an API route, guarded by role → src/api/<path>.ts
+  server-fn <name>            a "use server" function      → src/server/<name>.ts
+  auth oauth2 [--provider <p>] [--tokens browser|server]
+                              @fluixi/oauth2 wiring: env config, service, routes, .env.example
+                              (fluixi add auth does the same, asks, and installs)
+  auth better-auth            @fluixi/auth wiring          → auth.config + auth.client + middleware + /api/auth
 
+Modules and services are listed in src/app.config.ts, or app.config.server.ts for --server,
+which is created when missing. Providers: ${t.PROVIDERS.join(', ')}.
 Component/route syntax follows the project (JSX → .tsx, html\`\` → .ts); override with --jsx / --html.
 `;
 /**
@@ -76,6 +90,27 @@ function resolveHint(Name, ext) {
     console.log(`    ${c.gray(`resolve: [{ match: /^([A-Z]\\w+)$/, module: '/src/components/$1.${ext}' }]`)}`);
     console.log(`  ${c.gray('one pattern covers the whole folder. Importing it works too — including with')} ${c.cyan('load:')}`);
 }
+/** The value of `--name value` or `--name=value`. */
+function option(name) {
+    const args = process.argv;
+    const i = args.indexOf(`--${name}`);
+    if (i !== -1 && args[i + 1] && !args[i + 1].startsWith('--'))
+        return args[i + 1];
+    return args.find((a) => a.startsWith(`--${name}=`))?.slice(name.length + 3);
+}
+const kebab = (s) => s.replace(/([a-z0-9])([A-Z])/g, '$1-$2').toLowerCase();
+/** Write a file the app may already have, keeping theirs. Returns whether it wrote. */
+function writeOnce(file, content) {
+    const steps = [];
+    const wrote = writeOnceTo(steps, file, content);
+    report(steps);
+    return wrote;
+}
+function registerIn(server, file, name, entry = name) {
+    const steps = [];
+    registerModule(steps, process.cwd(), server, file, name, entry);
+    report(steps);
+}
 function write(file, content) {
     const rel = relative(process.cwd(), file);
     if (existsSync(file)) {
@@ -140,44 +175,6 @@ export default defineMiddleware([
   },
 ]);
 `;
-const authConfig = () => `import { betterAuth } from 'better-auth';
-import { defineAuth } from '@fluixi/auth/server';
-
-export type AppUser = { id: string; email: string; name?: string; role?: string };
-
-// Better Auth owns the audited primitives; defineAuth registers it with @fluixi/auth.
-export const auth = defineAuth<AppUser>(
-  betterAuth({
-    // database: <your adapter>,
-    emailAndPassword: { enabled: true },
-    // socialProviders: { google: { … }, github: { … } },
-  } as Parameters<typeof betterAuth>[0]),
-);
-`;
-const authClient = () => `import { createAuthClient } from 'better-auth/client';
-import { createAuthHooks } from '@fluixi/auth/client';
-import type { AppUser } from './auth.config.js';
-
-const client = createAuthClient({ baseURL: '/api/auth' });
-
-// Or, to reuse an existing reactive session: createAuthHooks({ session: yourSessionStore }).
-export const { useUser, useSession, useAuth, useSignIn, useSignOut, protectedRoute } =
-  createAuthHooks<AppUser>({ client, loginPath: '/login' });
-`;
-const authMiddleware = () => `import { defineMiddleware } from '@fluixi/start';
-import { authMiddleware } from '@fluixi/auth/server';
-import './auth.config.js';
-
-export default defineMiddleware([authMiddleware()]);
-`;
-const authRoute = () => `import { mountAuthRoutes } from '@fluixi/auth/server';
-import '../../../auth.config.js';
-
-const handler = mountAuthRoutes();
-export const GET = handler;
-export const POST = handler;
-export default handler;
-`;
 export function generate(kind, name) {
     switch (kind) {
         case 'component':
@@ -204,18 +201,91 @@ export function generate(kind, name) {
         case 'm':
             write(resolve('src/middleware.ts'), middleware());
             break;
+        case 'env': {
+            const names = (envPublicNames(resolve('fluixi.config.ts')) ?? []).filter((n) => !n.startsWith('AUTH_'));
+            write(resolve('src/config/env.ts'), t.envConfig(names));
+            break;
+        }
+        case 'module': {
+            if (!name)
+                return fail('module name required, e.g. `fluixi g module billing`');
+            const slug = kebab(name);
+            const file = resolve('src/services', slug, `${slug}.module.ts`);
+            write(file, t.moduleFile(pascal(name), slug));
+            registerIn(false, file, `${pascal(name)}Module`);
+            break;
+        }
+        case 'service':
+        case 's': {
+            if (!name)
+                return fail('service name required, e.g. `fluixi g service Orders`');
+            const Name = pascal(name).replace(/Service$/, '') || 'App';
+            const server = process.argv.includes('--server');
+            const file = resolve('src/services', `${kebab(Name)}${server ? '.server' : ''}.ts`);
+            write(file, t.serviceFile(Name, kebab(Name), server));
+            registerIn(server, file, `${Name}Module`);
+            break;
+        }
+        case 'api': {
+            if (!name)
+                return fail('api path required, e.g. `fluixi g api users/[id]`');
+            const file = resolve('src/api', `${name.replace(/\.ts$/, '')}.ts`);
+            const role = option('role');
+            if (!role) {
+                write(file, t.apiRoute());
+                break;
+            }
+            const verify = resolve('src/services/verify.server.ts');
+            write(file, t.guardedApiRoute(importPath(file, verify), role));
+            writeOnce(verify, t.verifyServer());
+            {
+                const steps = [];
+                ensureAuthEnv(steps, process.cwd());
+                report(steps);
+            }
+            break;
+        }
+        case 'server-fn': {
+            if (!name)
+                return fail('function name required, e.g. `fluixi g server-fn getUser`');
+            const fn = name.replace(/[^a-zA-Z0-9]+(.)/g, (_, ch) => ch.toUpperCase());
+            write(resolve('src/server', `${fn}.ts`), t.serverFn(fn));
+            break;
+        }
         case 'auth':
-            write(resolve('src/auth.config.ts'), authConfig());
-            write(resolve('src/auth.client.ts'), authClient());
-            write(resolve('src/middleware.ts'), authMiddleware());
-            write(resolve('src/routes/api/auth/[...all].ts'), authRoute());
-            console.log(`  ${c.gray('next: install')} ${c.cyan('better-auth')}${c.gray(', set your DB adapter in auth.config.ts, and forward `request` in entry-server')}`);
+            try {
+                if (name === 'oauth2') {
+                    reportAuth(setupOAuth2(process.cwd(), {
+                        provider: option('provider'),
+                        tokens: tokensOption(),
+                        format: detectFormat(),
+                    }), 'install @fluixi/oauth2');
+                }
+                else if (!name || name === 'better-auth') {
+                    reportAuth(setupBetterAuth(process.cwd()), 'install @fluixi/auth and better-auth');
+                }
+                else {
+                    return fail(`unknown auth kind ${name}: oauth2 or better-auth`);
+                }
+            }
+            catch (error) {
+                if (error instanceof ScaffoldError)
+                    return fail(error.message);
+                throw error;
+            }
             break;
         default:
             console.error(GEN_USAGE);
             process.exit(1);
     }
 }
+function tokensOption() {
+    const tokens = option('tokens');
+    if (tokens !== undefined && tokens !== 'browser' && tokens !== 'server') {
+        fail('--tokens is browser or server');
+    }
+    return tokens;
+}
 function fail(msg) {
     console.error(`  ${c.red('✗')} ${msg}`);
     process.exit(1);