@airoom/nextmin-node 2.0.2 → 2.0.3

package/dist/cli.js

@@ -1,83 +1,164 @@
+#!/usr/bin/env node
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const NMAdapter_1 = require("./database/NMAdapter");
-const SchemaLoader_1 = require("./utils/SchemaLoader");
 const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
 const dotenv_1 = __importDefault(require("dotenv"));
-dotenv_1.default.config();
-async function repairMongo() {
-    const mongoUri = process.env.MONGODB_URI;
-    const dbName = process.env.DB_NAME || 'test';
-    const schemasDir = process.env.SCHEMAS_DIR || path_1.default.join(process.cwd(), 'schemas');
-    if (!mongoUri) {
-        console.error('MONGODB_URI is required in .env');
-        process.exit(1);
+// Simple helper to parse CLI arguments of format --key value or --key
+function parseArgs(args) {
+    const parsed = {};
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg.startsWith('--')) {
+            const key = arg.slice(2);
+            const nextVal = args[i + 1];
+            if (nextVal && !nextVal.startsWith('--')) {
+                parsed[key] = nextVal;
+                i++;
+            }
+            else {
+                parsed[key] = 'true';
+            }
+        }
+    }
+    return parsed;
+}
+function findAndLoadEnv(customEnvPath) {
+    if (customEnvPath) {
+        const resolved = path_1.default.resolve(process.cwd(), customEnvPath);
+        if (fs_1.default.existsSync(resolved)) {
+            dotenv_1.default.config({ path: resolved });
+            console.log(`Loaded custom env file: ${resolved}`);
+            return;
+        }
+        else {
+            console.warn(`Custom env file not found: ${resolved}`);
+        }
+    }
+    let dir = process.cwd();
+    let envLoaded = false;
+    let envLocalLoaded = false;
+    // Traverse up to 5 parent directories to look for .env or .env.local
+    for (let i = 0; i < 5; i++) {
+        const envLocalPath = path_1.default.join(dir, '.env.local');
+        const envPath = path_1.default.join(dir, '.env');
+        if (!envLocalLoaded && fs_1.default.existsSync(envLocalPath)) {
+            dotenv_1.default.config({ path: envLocalPath });
+            console.log(`Loaded environment from: ${envLocalPath}`);
+            envLocalLoaded = true;
+        }
+        if (!envLoaded && fs_1.default.existsSync(envPath)) {
+            dotenv_1.default.config({ path: envPath });
+            console.log(`Loaded environment from: ${envPath}`);
+            envLoaded = true;
+        }
+        if (envLoaded && envLocalLoaded)
+            break;
+        const parent = path_1.default.dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
     }
-    console.log('--- NextMin MongoDB Repair Tool ---');
-    console.log(`Connecting to: ${mongoUri}`);
-    const loader = SchemaLoader_1.SchemaLoader.getInstance();
-    const schemaDefs = loader.getSchemas();
-    const adapter = new NMAdapter_1.NMAdapter({
-        type: 'mongodb',
-        url: mongoUri,
-        database: dbName,
-        useNewUrlParser: true,
-        useUnifiedTopology: true,
-        schemas: schemaDefs
-    });
+}
+const args = process.argv.slice(2);
+const command = args[0];
+const cliArgs = parseArgs(args.slice(1));
+// Load env before using any of the settings
+findAndLoadEnv(cliArgs['env']);
+async function runReindex(cliArgs) {
+    let diskConfig = {};
     try {
-        await adapter.connect();
-        await adapter.registerSchemas(schemaDefs);
-        for (const [name, schema] of Object.entries(schemaDefs)) {
-            if (schema.extends) {
-                console.log(`Checking ${name} (extends ${schema.extends})...`);
-                const items = await adapter.read(name, {});
-                const broken = items.filter(it => !it.baseId);
-                if (broken.length > 0) {
-                    console.log(`Found ${broken.length} items missing baseId in ${name}. Attempting repair...`);
-                    for (const item of broken) {
-                        const searchVal = item.slug || item.username || item.name;
-                        if (!searchVal)
-                            continue;
-                        // Try to find matching base record
-                        const baseMatches = await adapter.read(schema.extends, {
-                            $or: [
-                                { slug: searchVal },
-                                { username: searchVal },
-                                { name: searchVal }
-                            ]
-                        });
-                        if (baseMatches.length > 0) {
-                            const baseId = baseMatches[0].id;
-                            await adapter.update(name, item.id, { baseId });
-                            console.log(`  ✅ Repaired ${name} item '${searchVal}' -> baseId: ${baseId}`);
-                        }
-                        else {
-                            console.warn(`  ❌ Could not find matching ${schema.extends} for ${name} item '${searchVal}'`);
-                        }
-                    }
-                }
-                else {
-                    console.log(`  No broken links found in ${name}.`);
-                }
-            }
+        const configPath = path_1.default.join(process.cwd(), '.nextmin', 'config.json');
+        if (fs_1.default.existsSync(configPath)) {
+            diskConfig = JSON.parse(fs_1.default.readFileSync(configPath, 'utf-8'));
+            console.log(`Loaded chat widget config from: ${configPath}`);
         }
-        console.log('Repair process completed.');
     }
     catch (err) {
-        console.error('Repair failed:', err);
+        console.warn('Failed to read config from disk:', err);
+    }
+    const chatWidgetConfig = {
+        ...diskConfig,
+        enabled: cliArgs['enabled'] !== 'false' && process.env.NEXTMIN_CHAT_ENABLED !== 'false' && diskConfig.enabled !== false,
+        localModelPath: cliArgs['model-path'] || process.env.NEXTMIN_CHAT_MODEL_PATH || diskConfig.localModelPath,
+        frontendBuildPath: cliArgs['build-path'] || process.env.NEXTMIN_CHAT_FRONTEND_PATH || diskConfig.frontendBuildPath || './.next',
+        siteUrl: cliArgs['site-url'] || process.env.NEXTMIN_CHAT_SITE_URL || process.env.FRONTEND_URL || diskConfig.siteUrl || `http://localhost:${process.env.PORT || 3000}`,
+        scrapePaths: (cliArgs['scrape-paths'] || process.env.NEXTMIN_CHAT_SCRAPE_PATHS)
+            ? (cliArgs['scrape-paths'] || process.env.NEXTMIN_CHAT_SCRAPE_PATHS).split(',').map(s => s.trim())
+            : (diskConfig.scrapePaths || ['/']),
+        concurrency: parseInt(cliArgs['threads'] || cliArgs['concurrency'] || process.env.NEXTMIN_CHAT_CONCURRENCY || String(diskConfig.concurrency || 5), 10)
+    };
+    console.log('--- NextMin Reindex Tool (Local-Only) ---');
+    console.log(`Frontend Build Path: ${chatWidgetConfig.frontendBuildPath}`);
+    console.log(`Site Scrape URL:     ${chatWidgetConfig.siteUrl}`);
+    console.log(`Scrape Paths:        ${chatWidgetConfig.scrapePaths.join(', ')}`);
+    console.log(`Concurrency Threads: ${chatWidgetConfig.concurrency}`);
+    let hasError = false;
+    try {
+        const { reindex } = await Promise.resolve().then(() => __importStar(require('./services/IndexingService')));
+        await reindex({
+            chatWidget: chatWidgetConfig,
+            force: cliArgs['force'] === 'true'
+        });
+        console.log('Reindex completed successfully.');
+    }
+    catch (err) {
+        console.error('Reindex failed:', err);
+        hasError = true;
     }
     finally {
-        await adapter.disconnect();
+        if (hasError) {
+            process.exit(1);
+        }
     }
 }
-const command = process.argv[2];
-if (command === 'repair-mongo') {
-    repairMongo();
+if (command === 'reindex') {
+    runReindex(cliArgs);
 }
 else {
-    console.log('Usage: ts-node src/cli.ts repair-mongo');
+    console.log('Usage: npx nextmin-node <command> [options]');
+    console.log('\nCommands:');
+    console.log('  reindex       Index website files via scraping');
+    console.log('\nOptions:');
+    console.log('  --threads <count>    Number of concurrent scraping threads (default: 5)');
+    console.log('  --site-url <url>     Website URL to crawl');
+    console.log('  --build-path <path>  Path to Next.js build directory (.next)');
+    console.log('  --force              Force full reindexing and bypass manifest cache');
+    console.log('  --env <path>         Path to a custom environment (.env) file');
 }

package/dist/database/DatabaseAdapter.d.ts

@@ -19,4 +19,5 @@ export interface DatabaseAdapter {
     syncIndexes?(modelName: string, desired: FieldIndexSpec): Promise<void>;
     cleanupUnusedFields?(schemas: Record<string, Schema>): Promise<Record<string, string[]>>;
     isExclusiveProjection(projection: Record<string, 0 | 1> | undefined, schema: Schema | undefined): boolean;
+    formatUrlForRead?(val: string): string;
 }

package/dist/database/NMAdapter.d.ts

@@ -11,14 +11,20 @@ export declare class NMAdapter implements DatabaseAdapter {
     private entitySchemas;
     private registeredSchemas;
     private imageProxyOptions;
+    private queryCache;
     constructor(options: any);
     connect(): Promise<void>;
     disconnect(): Promise<void>;
     registerSchemas(schemas: Record<string, NextMinSchema>): Promise<void>;
+    private validateRefPathSchemas;
     syncIndexes(modelName: string, spec: FieldIndexSpec): Promise<void>;
     private buildEntitySchema;
     private mapType;
     private getRepository;
+    private getActiveBaseUrl;
+    private cleanUrlForStorage;
+    private cleanPayloadForStorage;
+    formatUrlForRead(val: string): string;
     create(collection: string, data: any, schemaDefinition?: NextMinSchema): Promise<any>;
     private coercePayloadForStorage;
     read(collection: string, query: any, limit?: number, skip?: number, schemaDefinition?: NextMinSchema, includePrivateFields?: boolean, options?: ReadOptions): Promise<any[]>;