@mono-labs/cli 0.0.194 → 0.0.195

package/dist/cdk/index.js

@@ -0,0 +1,51 @@
+export function replaceTokens(str, env) {
+    if (typeof str !== 'string')
+        return str;
+    return str.replace(/\$\{([^}]+)\}|\$([A-Z0-9_]+)/g, (m, k1, k2) => {
+        const k = k1 || k2;
+        // existing data layer takes priority (guarded in case not defined)
+        if (typeof hasData === 'function' && hasData(k)) {
+            const val = typeof getData === 'function' ? getData(k) : undefined;
+            return val == null ? '' : String(val);
+        }
+        // environment variables
+        if (env && Object.prototype.hasOwnProperty.call(env, k)) {
+            const val = env[k];
+            return val == null ? '' : String(val);
+        }
+        // fallback
+        return '';
+    });
+}
+function filterEnvByPrefix(env, prefix) {
+    const filtered = {};
+    for (const key in env) {
+        if (key.startsWith(prefix)) {
+            filtered[key] = env[key];
+        }
+    }
+    return filtered;
+}
+export function setUpConfig(config) {
+    const { extra = {}, ...other } = config.expo || {};
+    const router = extra['router'] ?
+        { origin: false, ...extra['router'] }
+        : {
+            origin: false,
+        };
+    const appConfig = {
+        ...config,
+        expo: {
+            ...other,
+            extra: {
+                ...filterEnvByPrefix(process.env, 'NEXT_PUBLIC_'),
+                eas: {
+                    projectId: process.env.EAS_PROJECT_ID,
+                },
+                router,
+                ...extra,
+            },
+        },
+    };
+    return appConfig;
+}

package/dist/expo.js

@@ -0,0 +1,51 @@
+export function replaceTokens(str, env) {
+    if (typeof str !== 'string')
+        return str;
+    return str.replace(/\$\{([^}]+)\}|\$([A-Z0-9_]+)/g, (m, k1, k2) => {
+        const k = k1 || k2;
+        // existing data layer takes priority (guarded in case not defined)
+        if (typeof hasData === 'function' && hasData(k)) {
+            const val = typeof getData === 'function' ? getData(k) : undefined;
+            return val == null ? '' : String(val);
+        }
+        // environment variables
+        if (env && Object.prototype.hasOwnProperty.call(env, k)) {
+            const val = env[k];
+            return val == null ? '' : String(val);
+        }
+        // fallback
+        return '';
+    });
+}
+function filterEnvByPrefix(env, prefix) {
+    const filtered = {};
+    for (const key in env) {
+        if (key.startsWith(prefix)) {
+            filtered[key] = env[key];
+        }
+    }
+    return filtered;
+}
+export function setUpConfig(config) {
+    const { extra = {}, ...other } = config.expo || {};
+    const router = extra['router'] ?
+        { origin: false, ...extra['router'] }
+        : {
+            origin: false,
+        };
+    const appConfig = {
+        ...config,
+        expo: {
+            ...other,
+            extra: {
+                ...filterEnvByPrefix(process.env, 'NEXT_PUBLIC_'),
+                eas: {
+                    projectId: process.env.EAS_PROJECT_ID,
+                },
+                router,
+                ...extra,
+            },
+        },
+    };
+    return appConfig;
+}

package/dist/merge-env.js

@@ -0,0 +1,25 @@
+import fs from 'fs';
+import path from 'path';
+import dotenv from 'dotenv';
+export function loadMergedEnv() {
+    const ENV_PATH = path.resolve(process.cwd(), '.env');
+    const ENV_LOCAL_PATH = path.resolve(process.cwd(), '.env.local');
+    // Load base .env
+    const base = fs.existsSync(ENV_PATH) ? dotenv.parse(fs.readFileSync(ENV_PATH)) : {};
+    // Load overrides .env.local
+    const local = fs.existsSync(ENV_LOCAL_PATH) ?
+        dotenv.parse(fs.readFileSync(ENV_LOCAL_PATH))
+        : {};
+    // Merge: local overrides base
+    const merged = {
+        ...base,
+        ...local,
+    };
+    // Inject into process.env (do NOT overwrite existing real env vars)
+    for (const [key, value] of Object.entries(merged)) {
+        if (process.env[key] === undefined) {
+            process.env[key] = value;
+        }
+    }
+    return process.env;
+}

package/dist/project/index.js

@@ -0,0 +1,65 @@
+import fs from 'node:fs';
+import path from 'node:path';
+/**
+ * Finds the workspace root by walking up from `startDir`.
+ * Works for Yarn/npm workspaces via package.json "workspaces".
+ * Also recognizes common mono-repo markers as fallback.
+ */
+export function detectWorkspaceAndConfigPath(startDir = process.cwd(), configFileName = 'app.config.json') {
+    const cwd = path.resolve(startDir);
+    const isWorkspaceRootDir = (dir) => {
+        // 1) package.json workspaces
+        const pkgPath = path.join(dir, 'package.json');
+        if (fs.existsSync(pkgPath)) {
+            try {
+                const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+                if (pkg?.workspaces)
+                    return true;
+            }
+            catch {
+                // ignore
+            }
+        }
+        // 2) other common monorepo root markers (fallback)
+        const markers = [
+            'pnpm-workspace.yaml',
+            'lerna.json',
+            'turbo.json',
+            'nx.json',
+            '.git', // good enough for many repos
+        ];
+        return markers.some((m) => fs.existsSync(path.join(dir, m)));
+    };
+    const findUp = (from, predicate) => {
+        let dir = path.resolve(from);
+        while (true) {
+            if (predicate(dir))
+                return dir;
+            const parent = path.dirname(dir);
+            if (parent === dir)
+                return null; // reached filesystem root
+            dir = parent;
+        }
+    };
+    const workspaceRoot = findUp(cwd, isWorkspaceRootDir);
+    const isWorkspaceRoot = workspaceRoot !== null && workspaceRoot === cwd;
+    // If we are inside a workspace package, config lives at root.
+    // If we're already at root, config lives in cwd (same thing).
+    const configDir = workspaceRoot ?? cwd;
+    const configPath = path.join(configDir, configFileName);
+    return { cwd, workspaceRoot, isWorkspaceRoot, configDir, configPath };
+}
+export function loadAppConfig(configType = 'app', startDir = process.cwd()) {
+    const fileName = `${configType}.config.json`;
+    const meta = detectWorkspaceAndConfigPath(startDir, fileName);
+    if (!fs.existsSync(meta.configPath)) {
+        const where = meta.workspaceRoot ?
+            `workspace root: ${meta.workspaceRoot}`
+            : `cwd: ${meta.cwd}`;
+        throw new Error(`Could not find ${fileName} at ${meta.configPath} (detected from ${where}).`);
+    }
+    const raw = fs.readFileSync(meta.configPath, 'utf8');
+    return { config: JSON.parse(raw), meta };
+}
+export const loadProjectConfig = loadAppConfig;
+export { loadMergedEnv } from './merge-env.js';

package/dist/project/merge-env.js

@@ -0,0 +1,25 @@
+import fs from 'fs';
+import path from 'path';
+import dotenv from 'dotenv';
+export function loadMergedEnv() {
+    const ENV_PATH = path.resolve(process.cwd(), '.env');
+    const ENV_LOCAL_PATH = path.resolve(process.cwd(), '.env.local');
+    // Load base .env
+    const base = fs.existsSync(ENV_PATH) ? dotenv.parse(fs.readFileSync(ENV_PATH)) : {};
+    // Load overrides .env.local
+    const local = fs.existsSync(ENV_LOCAL_PATH) ?
+        dotenv.parse(fs.readFileSync(ENV_LOCAL_PATH))
+        : {};
+    // Merge: local overrides base
+    const merged = {
+        ...base,
+        ...local,
+    };
+    // Inject into process.env (do NOT overwrite existing real env vars)
+    for (const [key, value] of Object.entries(merged)) {
+        if (process.env[key] === undefined) {
+            process.env[key] = value;
+        }
+    }
+    return process.env;
+}

package/dist/stack.js

@@ -0,0 +1,51 @@
+import * as cdk from 'aws-cdk-lib';
+import { loadMergedEnv } from './project/merge-env.js';
+loadMergedEnv();
+//cdk deploy --context owner=cody --context region=us-west-1
+const dev = 'dev';
+export class CustomStack extends cdk.Stack {
+    ownerName;
+    region;
+    domainName;
+    enableNATGateway = false;
+    constructor(scope, id, props = {}) {
+        // 🔑 Resolve account + region BEFORE super()
+        const resolvedEnv = {
+            account: props.env?.account ?? process.env.AWS_ACCOUNT ?? cdk.Aws.ACCOUNT_ID, // final fallback (lazy token)
+            region: props.env?.region ?? process.env.AWS_REGION ?? 'us-east-2',
+        };
+        super(scope, id, {
+            ...props,
+            env: resolvedEnv,
+        });
+        // ✅ Now it’s safe to read these
+        this.ownerName = props.ownerName ?? 'dev';
+        this.domainName = props.domainName;
+        this.region = resolvedEnv.region;
+        this.enableNATGateway = props.enableNATGateway ?? false;
+    }
+    initializeStackConfig() {
+        // Context overrides (deploy-time flags)
+        const ctxOwner = this.node.tryGetContext('owner') || dev;
+        const ctxRegion = this.node.tryGetContext('region') || 'us-east-2';
+        const ctxNat = this.node.tryGetContext('enableNATGateway');
+        if (ctxOwner)
+            this.ownerName = ctxOwner;
+        if (ctxRegion)
+            this.region = ctxRegion;
+        // NAT logic
+        if (ctxNat !== undefined) {
+            this.enableNATGateway = ctxNat === 'true';
+        }
+        // Production default
+        if (this.ownerName === 'prod' || this.ownerName === 'production') {
+            this.enableNATGateway = ctxNat !== 'false';
+        }
+        console.log('[Stack Config]', {
+            owner: this.ownerName,
+            region: this.region,
+            account: this.account,
+            natGateway: this.enableNATGateway,
+        });
+    }
+}

package/dist/tools.js

@@ -0,0 +1,32 @@
+function filterEnvByPrefix(env, prefix) {
+    const filtered = {};
+    for (const key in env) {
+        if (key.startsWith(prefix)) {
+            filtered[key] = env[key];
+        }
+    }
+    return filtered;
+}
+export function setUpConfig(config) {
+    const { extra = {}, ...other } = config.expo || {};
+    const router = extra['router'] ?
+        { origin: false, ...extra['router'] }
+        : {
+            origin: false,
+        };
+    const appConfig = {
+        ...config,
+        expo: {
+            ...other,
+            extra: {
+                ...filterEnvByPrefix(process.env, 'NEXT_PUBLIC_'),
+                eas: {
+                    projectId: process.env.EAS_PROJECT_ID,
+                },
+                router,
+                ...extra,
+            },
+        },
+    };
+    return appConfig;
+}

package/dist/types/cdk/index.d.ts

@@ -0,0 +1,2 @@
+export function replaceTokens(str: any, env: any): any;
+export function setUpConfig(config: any): any;

package/dist/types/expo.d.ts

@@ -0,0 +1,2 @@
+export function replaceTokens(str: any, env: any): any;
+export function setUpConfig(config: any): any;

package/dist/types/merge-env.d.ts

@@ -0,0 +1 @@
+export function loadMergedEnv(): NodeJS.ProcessEnv;

package/dist/types/project/index.d.ts

@@ -0,0 +1,43 @@
+type WorkspaceDetectResult = {
+    cwd: string;
+    workspaceRoot: string | null;
+    isWorkspaceRoot: boolean;
+    configDir: string;
+    configPath: string;
+};
+/**
+ * Finds the workspace root by walking up from `startDir`.
+ * Works for Yarn/npm workspaces via package.json "workspaces".
+ * Also recognizes common mono-repo markers as fallback.
+ */
+export declare function detectWorkspaceAndConfigPath(startDir?: string, configFileName?: string): WorkspaceDetectResult;
+type DefaultAppConfig = {
+    appleAppId?: string;
+    androidAppId?: string;
+    appName?: string;
+    easProjectId?: string;
+    appScheme?: string;
+    regions?: string[];
+};
+type DefaultDeployConfig = {
+    baseDomain?: string;
+    webSubdomain?: string;
+    apiSubdomain?: string;
+    defaultKeyPair?: string;
+    regions?: string[];
+};
+type ConfigTypeMap = {
+    app: DefaultAppConfig;
+    deployment: DefaultDeployConfig;
+};
+/**
+ * If TType is a known key, use the mapped type.
+ * Otherwise use TCustom (default = unknown).
+ */
+type ResolveConfig<TType extends string, TCustom = unknown> = TType extends keyof ConfigTypeMap ? ConfigTypeMap[TType] : TCustom;
+export declare function loadAppConfig<TCustom = unknown, TType extends string = 'app'>(configType?: TType, startDir?: string): {
+    config: ResolveConfig<TType, TCustom>;
+    meta: WorkspaceDetectResult;
+};
+export declare const loadProjectConfig: typeof loadAppConfig;
+export { loadMergedEnv } from './merge-env.js';

package/dist/types/project/merge-env.d.ts

@@ -0,0 +1 @@
+export declare function loadMergedEnv(): NodeJS.ProcessEnv;

package/dist/types/stack.d.ts

@@ -0,0 +1,21 @@
+import * as cdk from 'aws-cdk-lib';
+import { Construct } from 'constructs';
+export interface ICustomStack extends cdk.Stack {
+    ownerName: string;
+    region: string;
+    enableNATGateway: boolean;
+}
+export interface CustomStackProps extends cdk.StackProps {
+    ownerName?: string;
+    region?: string;
+    enableNATGateway?: boolean;
+    domainName?: string;
+}
+export declare abstract class CustomStack extends cdk.Stack {
+    ownerName: string;
+    region: string;
+    domainName?: string;
+    protected enableNATGateway: boolean;
+    constructor(scope: Construct, id: string, props?: CustomStackProps);
+    initializeStackConfig(): void;
+}

package/dist/types/tools.d.ts

@@ -0,0 +1 @@
+export function setUpConfig(config: any): any;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@mono-labs/cli",
-    "version": "0.0.194",
+    "version": "0.0.195",
     "description": "A CLI tool for building and deploying projects",
     "type": "module",
     "main": "dist/index.js",
@@ -85,6 +85,7 @@
         "bin/",
         "lib/",
         "src/",
+        "dist/",
         "types.d.ts",
         "README.md"
     ]