@emeryld/manager 1.3.0 → 1.4.0

package/dist/create-package/shared/fs-utils.js

@@ -0,0 +1,69 @@
+import { access, mkdir, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { promptYesNoAll } from '../../prompts.js';
+import { baseEslintConfig, basePrettierConfig, HUSKY_PRE_COMMIT, pathExists, PRETTIER_IGNORE, resolveRootTsconfig, toPosixPath, vscodeSettings, } from './configs.js';
+import { workspaceRoot } from './constants.js';
+export async function writeFileIfMissing(baseDir, relative, contents) {
+    const fullPath = path.join(baseDir, relative);
+    await mkdir(path.dirname(fullPath), { recursive: true });
+    try {
+        await access(fullPath);
+        const rel = path.relative(workspaceRoot, fullPath);
+        console.log(`  skipped ${rel} (already exists)`);
+        return 'skipped';
+    }
+    catch (error) {
+        if (error &&
+            typeof error === 'object' &&
+            error.code !== 'ENOENT') {
+            throw error;
+        }
+    }
+    await writeFile(fullPath, contents, 'utf8');
+    const rel = path.relative(workspaceRoot, fullPath);
+    console.log(`  created ${rel}`);
+    return 'created';
+}
+export async function writeFileWithPrompt(baseDir, relative, contents) {
+    const fullPath = path.join(baseDir, relative);
+    await mkdir(path.dirname(fullPath), { recursive: true });
+    const rel = path.relative(workspaceRoot, fullPath);
+    const exists = await pathExists(fullPath);
+    if (exists) {
+        const answer = await promptYesNoAll(`Overwrite existing ${rel}?`);
+        if (answer !== 'yes') {
+            console.log(`  kept existing ${rel}`);
+            return 'skipped';
+        }
+    }
+    await writeFile(fullPath, contents, 'utf8');
+    console.log(`  ${exists ? 'updated' : 'created'} ${rel}`);
+    return exists ? 'updated' : 'created';
+}
+export function workspaceToolingFiles(tsconfigPath) {
+    return {
+        'eslint.config.js': baseEslintConfig(tsconfigPath),
+        'prettier.config.js': basePrettierConfig(),
+        '.prettierignore': `${PRETTIER_IGNORE}\n`,
+        '.vscode/settings.json': vscodeSettings(),
+        '.husky/pre-commit': HUSKY_PRE_COMMIT,
+    };
+}
+export async function ensureWorkspaceToolingFiles(baseDir, options) {
+    const defaultTsconfig = path.join(baseDir, 'tsconfig.json');
+    const resolvedRootConfig = options?.tsconfigPath
+        ? path.resolve(baseDir, options.tsconfigPath)
+        : await resolveRootTsconfig(baseDir);
+    const relativeTsconfig = path.relative(baseDir, resolvedRootConfig ?? defaultTsconfig);
+    const normalized = toPosixPath(relativeTsconfig || './tsconfig.json');
+    const tsconfigPath = normalized.startsWith('.') ? normalized : `./${normalized}`;
+    const files = workspaceToolingFiles(tsconfigPath);
+    for (const [relative, contents] of Object.entries(files)) {
+        await writeFileWithPrompt(baseDir, relative, contents);
+    }
+}
+export async function writeFilesIfMissing(baseDir, files) {
+    for (const [relative, contents] of Object.entries(files)) {
+        await writeFileIfMissing(baseDir, relative, contents);
+    }
+}

package/dist/create-package/tasks.js

@@ -0,0 +1,89 @@
+import { mkdir, readdir, readFile, rm, stat } from 'node:fs/promises';
+import path from 'node:path';
+import { colors, logGlobal } from '../utils/log.js';
+import { run } from '../utils/run.js';
+import { workspaceRoot } from './shared.js';
+export async function ensureTargetDir(targetDir, options) {
+    const resolvedTarget = path.resolve(targetDir);
+    const shouldReset = options?.reset ?? false;
+    if (shouldReset && resolvedTarget === workspaceRoot) {
+        throw new Error('Refusing to reset the workspace root directory.');
+    }
+    try {
+        const stats = await stat(targetDir);
+        if (!stats.isDirectory()) {
+            throw new Error(`Target "${targetDir}" exists and is not a directory.`);
+        }
+        if (shouldReset) {
+            logGlobal(`Resetting existing target ${path.relative(workspaceRoot, resolvedTarget) || '.'}…`, colors.yellow);
+            await rm(resolvedTarget, { recursive: true, force: true });
+            await mkdir(resolvedTarget, { recursive: true });
+            return;
+        }
+        const entries = await readdir(targetDir);
+        if (entries.length > 0) {
+            logGlobal(`Target ${path.relative(workspaceRoot, targetDir)} is not empty; existing files will be preserved.`, colors.yellow);
+        }
+    }
+    catch (error) {
+        if (error &&
+            typeof error === 'object' &&
+            error.code === 'ENOENT') {
+            await mkdir(resolvedTarget, { recursive: true });
+            return;
+        }
+        throw error;
+    }
+}
+export async function postCreateTasks(targetDir, options) {
+    if (options?.skipInstall) {
+        logGlobal('Skipping pnpm install (flag).', colors.dim);
+        return;
+    }
+    try {
+        logGlobal('Running pnpm install…', colors.cyan);
+        await run('pnpm', ['install'], { cwd: workspaceRoot });
+    }
+    catch (error) {
+        logGlobal(`pnpm install failed: ${error instanceof Error ? error.message : String(error)}`, colors.yellow);
+        return;
+    }
+    if (options?.skipBuild) {
+        logGlobal('Skipping build (flag).', colors.dim);
+        return;
+    }
+    try {
+        if (options?.pkgName) {
+            logGlobal(`Building workspace deps for ${options.pkgName}…`, colors.cyan);
+            await run('pnpm', ['-r', '--filter', `${options.pkgName}...`, 'build'], {
+                cwd: workspaceRoot,
+            });
+            return;
+        }
+    }
+    catch (error) {
+        logGlobal(`Filtered workspace build failed; will try full workspace build: ${error instanceof Error ? error.message : String(error)}`, colors.yellow);
+    }
+    try {
+        logGlobal('Building full workspace…', colors.cyan);
+        await run('pnpm', ['-r', 'build'], { cwd: workspaceRoot });
+        return;
+    }
+    catch (error) {
+        logGlobal(`Full workspace build failed; falling back to building only the new package: ${error instanceof Error ? error.message : String(error)}`, colors.yellow);
+    }
+    try {
+        const pkgJsonPath = path.join(targetDir, 'package.json');
+        const pkgRaw = await readFile(pkgJsonPath, 'utf8');
+        const pkg = JSON.parse(pkgRaw);
+        if (pkg.scripts?.build) {
+            logGlobal('Running pnpm run build for the new package…', colors.cyan);
+            await run('pnpm', ['-C', targetDir, 'run', 'build'], {
+                cwd: workspaceRoot,
+            });
+        }
+    }
+    catch (error) {
+        logGlobal(`Skipping build (could not read package.json): ${error instanceof Error ? error.message : String(error)}`, colors.yellow);
+    }
+}

package/dist/create-package/types.js

@@ -0,0 +1 @@
+export {};

package/dist/create-package/variant-info.js

@@ -0,0 +1,67 @@
+import path from 'node:path';
+import { colors, logGlobal } from '../utils/log.js';
+import { SCRIPT_DESCRIPTIONS } from './shared.js';
+import { clientVariant } from './variants/client.js';
+import { contractVariant } from './variants/contract.js';
+import { dockerVariant } from './variants/docker.js';
+import { emptyVariant } from './variants/empty.js';
+import { fullstackVariant } from './variants/fullstack.js';
+import { serverVariant } from './variants/server.js';
+export const VARIANTS = [
+    contractVariant,
+    serverVariant,
+    clientVariant,
+    emptyVariant,
+    dockerVariant,
+    fullstackVariant,
+];
+export const VARIANT_LOOKUP = new Map(VARIANTS.map((variant) => [variant.id, variant]));
+export function derivePackageName(targetDir) {
+    const base = path.basename(targetDir) || 'rrr-package';
+    return base;
+}
+export function resolveVariant(key) {
+    if (!key)
+        return undefined;
+    const normalized = key.toLowerCase();
+    return (VARIANT_LOOKUP.get(normalized) ??
+        VARIANTS.find((variant) => {
+            const label = variant.label.toLowerCase();
+            const id = variant.id.toLowerCase();
+            return (id === normalized ||
+                id.replace(/^rrr-/, '') === normalized ||
+                label === normalized ||
+                label.includes(normalized));
+        }));
+}
+export function printVariantList() {
+    logGlobal('Available templates', colors.magenta);
+    VARIANTS.forEach((variant) => {
+        const summary = variant.summary ? ` ${colors.dim(`– ${variant.summary}`)}` : '';
+        console.log(`- ${colors.green(variant.label)} ${colors.dim(`(${variant.id})`)} → ${colors.cyan(variant.defaultDir)}${summary}`);
+    });
+    console.log(colors.dim('Use "--describe <variant>" for details or "--variant <id> --dir <path>" to scaffold without prompts.'));
+}
+export function printVariantDetails(variant) {
+    logGlobal(`${variant.label} (${variant.id})`, colors.green);
+    console.log(`  default dir: ${colors.cyan(variant.defaultDir)}`);
+    if (variant.summary) {
+        console.log(`  ${variant.summary}`);
+    }
+    if (variant.keyFiles?.length) {
+        console.log('  key files:');
+        variant.keyFiles.forEach((file) => console.log(`    - ${file}`));
+    }
+    if (variant.scripts?.length) {
+        console.log('  scripts:');
+        variant.scripts.forEach((script) => {
+            const desc = SCRIPT_DESCRIPTIONS[script];
+            const detail = desc ? colors.dim(` – ${desc}`) : '';
+            console.log(`    - ${script}${detail}`);
+        });
+    }
+    if (variant.notes?.length) {
+        console.log('  notes:');
+        variant.notes.forEach((note) => console.log(`    - ${note}`));
+    }
+}

package/dist/create-package/variants/client/expo-react-native/lib-files.js

@@ -0,0 +1,168 @@
+export function nativeQueryClient(contractImport) {
+    if (contractImport) {
+        return `import Constants from 'expo-constants'
+import { QueryClient } from '@tanstack/react-query'
+import { createRouteClient } from '@emeryld/rrroutes-client'
+import { registry } from '${contractImport}'
+
+const { apiUrl } = (Constants.expoConfig?.extra ?? {}) as Record<string, string>
+
+export const queryClient = new QueryClient()
+
+export const routeClient = createRouteClient({
+  baseUrl: apiUrl ?? 'http://localhost:4000',
+  queryClient,
+})
+
+export const healthGet = routeClient.build(registry.byKey['GET /api/health'])
+export const healthPost = routeClient.build(registry.byKey['POST /api/health'])
+export const hasContract = true as const
+`;
+    }
+    return `import Constants from 'expo-constants'
+import { QueryClient } from '@tanstack/react-query'
+import { createRouteClient } from '@emeryld/rrroutes-client'
+
+const { apiUrl } = (Constants.expoConfig?.extra ?? {}) as Record<string, string>
+
+export const queryClient = new QueryClient()
+
+export const routeClient = createRouteClient({
+  baseUrl: apiUrl ?? 'http://localhost:4000',
+  queryClient,
+})
+
+type RouteEndpoint = ReturnType<typeof routeClient.build>
+
+function placeholderUseEndpoint() {
+  const error = new Error('Add your contract import to src/queryClient.ts')
+  return {
+    data: undefined,
+    error,
+    refetch: () => undefined,
+    mutateAsync: async () => Promise.reject(error),
+    isPending: false,
+  }
+}
+
+const placeholderEndpoint = {
+  useEndpoint: placeholderUseEndpoint,
+} as unknown as RouteEndpoint
+
+export const healthGet: RouteEndpoint = placeholderEndpoint
+export const healthPost: RouteEndpoint = placeholderEndpoint
+export const hasContract = false as const
+`;
+}
+export function nativeSocket(contractImport) {
+    if (contractImport) {
+        return `import React from 'react'
+import Constants from 'expo-constants'
+import { io, type Socket } from 'socket.io-client'
+import {
+  buildSocketProvider,
+  type SocketClientOptions,
+} from '@emeryld/rrroutes-client'
+import { socketConfig, socketEvents } from '${contractImport}'
+
+const extras = (Constants.expoConfig?.extra ?? {}) as Record<string, string>
+const socketUrl = extras.socketUrl ?? 'http://localhost:4000'
+const socketPath = extras.socketPath ?? '/socket.io'
+
+const sysEvents: SocketClientOptions<
+  typeof socketEvents,
+  typeof socketConfig
+>['sys'] = {
+  'sys:connect': async ({ socket }) => {
+    console.log('socket connected', socket.id)
+  },
+  'sys:disconnect': async ({ reason }) => console.log('disconnected', reason),
+  'sys:reconnect': async ({ attempt, socket }) =>
+    console.log('reconnect', attempt, socket?.id),
+  'sys:connect_error': async ({ error }) =>
+    console.warn('socket connect error', error),
+  'sys:ping': () => ({
+    note: 'client-heartbeat',
+    sentAt: new Date().toISOString(),
+  }),
+  'sys:pong': async ({ payload }) => console.log('pong', payload),
+  'sys:room_join': async ({ rooms }) => {
+    console.log('join rooms', rooms)
+    return true
+  },
+  'sys:room_leave': async ({ rooms }) => {
+    console.log('leave rooms', rooms)
+    return true
+  },
+}
+
+const baseOptions: Omit<
+  SocketClientOptions<typeof socketEvents, typeof socketConfig>,
+  'socket'
+> = {
+  config: socketConfig,
+  sys: sysEvents,
+  heartbeat: { intervalMs: 15_000, timeoutMs: 7_500 },
+  debug: { connection: true },
+}
+
+const { SocketProvider, useSocketClient, useSocketConnection } =
+  buildSocketProvider({
+    events: socketEvents,
+    options: baseOptions,
+  })
+
+function getSocket(): Promise<Socket> {
+  return Promise.resolve(
+    io(socketUrl, {
+      path: socketPath,
+      transports: ['websocket'],
+    }),
+  )
+}
+
+export const roomMeta = { room: 'health' }
+export const socketReady = true as const
+
+export function AppSocketProvider(props: React.PropsWithChildren) {
+  return (
+    <SocketProvider
+      getSocket={getSocket}
+      destroyLeaveMeta={roomMeta}
+      fallback={<></>}
+    >
+      {props.children}
+    </SocketProvider>
+  )
+}
+
+export { useSocketClient, useSocketConnection }
+`;
+    }
+    return `import React from 'react'
+
+export const roomMeta = { room: 'health' }
+export const socketReady = false as const
+
+const stubSocket = {
+  connect: () =>
+    console.info('Socket disabled; add your contract import in src/socket.tsx.'),
+  disconnect: () => undefined,
+  emit: () => undefined,
+  joinRooms: () => undefined,
+  leaveRooms: () => undefined,
+}
+
+export function AppSocketProvider(props: React.PropsWithChildren) {
+  return <>{props.children}</>
+}
+
+export function useSocketClient() {
+  return stubSocket
+}
+
+export function useSocketConnection() {
+  // no-op when sockets are not configured
+}
+`;
+}

package/dist/create-package/variants/client/expo-react-native/package-files.js

@@ -0,0 +1,94 @@
+import { basePackageJson, baseScripts } from '../../../shared.js';
+export const EXPO_CLIENT_SCRIPTS = [
+    'dev',
+    'build',
+    'typecheck',
+    'lint',
+    'lint:fix',
+    'format',
+    'format:check',
+    'clean',
+    'start',
+    'android',
+    'ios',
+    'web',
+    'test',
+];
+function slugify(name) {
+    const cleaned = name.replace(/^@/, '').replace(/\//g, '-');
+    const slug = cleaned
+        .split(/[^a-zA-Z0-9]+/)
+        .filter(Boolean)
+        .join('-')
+        .toLowerCase();
+    return slug || 'rrr-client';
+}
+export function nativePackageJson(name, contractName, includePrepare) {
+    const dependencies = {
+        '@emeryld/rrroutes-client': '^2.5.3',
+        '@tanstack/react-query': '^5.90.12',
+        expo: '~52.0.8',
+        'expo-constants': '~16.0.2',
+        'expo-status-bar': '~2.0.1',
+        react: '18.3.1',
+        'react-native': '0.76.6',
+        'react-native-safe-area-context': '4.12.0',
+        'react-native-screens': '4.4.0',
+        'socket.io-client': '^4.8.3',
+        zod: '^4.2.1',
+    };
+    if (contractName)
+        dependencies[contractName] = 'workspace:*';
+    const devDependencies = {
+        '@babel/core': '^7.25.2',
+        '@types/react': '~18.2.79',
+        '@types/react-native': '~0.73.0',
+        'babel-preset-expo': '^11.0.0',
+        typescript: '^5.9.3',
+    };
+    return basePackageJson({
+        name,
+        main: 'expo/AppEntry',
+        useDefaults: false,
+        scripts: baseScripts('expo start', {
+            start: 'expo start',
+            android: 'expo start --android',
+            ios: 'expo start --ios',
+            web: 'expo start --web',
+            build: 'tsc -p tsconfig.json --noEmit',
+            test: 'echo "add tests"',
+        }, { includePrepare }),
+        dependencies,
+        devDependencies,
+    });
+}
+export function nativeAppJson(pkgName) {
+    const baseSlug = slugify(pkgName);
+    const slug = `${baseSlug}-client`;
+    return `${JSON.stringify({
+        expo: {
+            name: slug,
+            slug,
+            version: '0.1.0',
+            orientation: 'portrait',
+            scheme: baseSlug,
+            platforms: ['ios', 'android', 'web'],
+            userInterfaceStyle: 'light',
+            extra: {
+                apiUrl: 'http://localhost:4000',
+                socketUrl: 'http://localhost:4000',
+                socketPath: '/socket.io',
+            },
+            experiments: {
+                typedRoutes: false,
+            },
+        },
+    }, null, 2)}\n`;
+}
+export const NATIVE_BABEL = `module.exports = function (api) {
+  api.cache(true)
+  return {
+    presets: ['babel-preset-expo'],
+  }
+}
+`;

package/dist/create-package/variants/client/expo-react-native/scaffold.js

@@ -0,0 +1,59 @@
+import { ModuleResolutionKind } from 'typescript';
+import { basePackageFiles, buildReadme, isWorkspaceRoot, packageTsConfig, writeFilesIfMissing, } from '../../../shared.js';
+import { EXPO_CLIENT_SCRIPTS, NATIVE_BABEL, nativeAppJson, nativePackageJson, } from './package-files.js';
+import { nativeAppTsx, nativeHealthScreen } from './ui-files.js';
+import { nativeQueryClient, nativeSocket } from './lib-files.js';
+export async function scaffoldExpoReactNativeClient(ctx) {
+    const includePrepare = isWorkspaceRoot(ctx.targetDir);
+    const tsconfig = await packageTsConfig(ctx.targetDir, {
+        include: ['App.tsx', 'src/**/*.ts', 'src/**/*.tsx'],
+        jsx: 'react-native',
+        types: ['react', 'react-native'],
+        target: 'ES2022',
+        module: 'ESNext',
+        ModuleResolutionKind: ModuleResolutionKind.Bundler,
+        rootDir: '.',
+    });
+    const files = {
+        'package.json': nativePackageJson(ctx.pkgName, ctx.contractName, includePrepare),
+        'tsconfig.json': tsconfig,
+        'app.json': nativeAppJson(ctx.pkgName),
+        'babel.config.js': NATIVE_BABEL,
+        'App.tsx': nativeAppTsx(),
+        'src/queryClient.ts': nativeQueryClient(ctx.contractName),
+        'src/socket.tsx': nativeSocket(ctx.contractName),
+        'src/screens/HealthScreen.tsx': nativeHealthScreen(),
+        'README.md': buildReadme({
+            name: ctx.pkgName,
+            description: 'Expo + React Native RRRoutes client scaffold.',
+            scripts: [...EXPO_CLIENT_SCRIPTS],
+            sections: [
+                {
+                    title: 'Getting Started',
+                    lines: [
+                        '- Install deps: `npm install` (or `pnpm install`).',
+                        '- Start Expo dev server: `npm run dev` (or `npm start`).',
+                        '- Launch on device/simulator: `npm run android`, `npm run ios`, or `npm run web`.',
+                    ],
+                },
+                {
+                    title: 'Contract wiring',
+                    lines: [
+                        ctx.contractName
+                            ? `- Contract wired to ${ctx.contractName}; adjust the import in \`src/queryClient.ts\` if needed.`
+                            : '- Update `src/queryClient.ts` and `src/socket.tsx` with your contract import to enable HTTP + socket helpers.',
+                    ],
+                },
+                {
+                    title: 'Environment',
+                    lines: [
+                        '- `app.json` extra values (`apiUrl`, `socketUrl`, `socketPath`) configure runtime endpoints.',
+                        '- Update those values or read from native env as needed.',
+                    ],
+                },
+            ],
+        }),
+        ...basePackageFiles(),
+    };
+    await writeFilesIfMissing(ctx.targetDir, files);
+}