@getvision/core 0.0.0 → 0.0.1

package/dist/utils/service-detection.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Package info detected from package.json
+ */
+export interface PackageInfo {
+    name: string;
+    version: string;
+}
+/**
+ * Integration configuration
+ */
+export interface IntegrationConfig {
+    database?: string;
+    redis?: string;
+    [key: string]: string | undefined;
+}
+/**
+ * Drizzle detection result
+ */
+export interface DrizzleInfo {
+    detected: boolean;
+    configPath?: string;
+}
+/**
+ * Auto-detect package.json for service name and version
+ */
+export declare function autoDetectPackageInfo(): PackageInfo;
+/**
+ * Auto-detect integrations from environment variables
+ */
+export declare function autoDetectIntegrations(): IntegrationConfig;
+/**
+ * Detect Drizzle configuration
+ */
+export declare function detectDrizzle(): DrizzleInfo;
+/**
+ * Start Drizzle Studio
+ */
+export declare function startDrizzleStudio(port?: number): boolean;
+/**
+ * Stop Drizzle Studio
+ */
+export declare function stopDrizzleStudio(): void;
+//# sourceMappingURL=service-detection.d.ts.map

package/dist/utils/service-detection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service-detection.d.ts","sourceRoot":"","sources":["../../src/utils/service-detection.ts"],"names":[],"mappings":"AAIA;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,EAAE,MAAM,CAAA;CAChB;AAED;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAAA;CAClC;AAED;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,QAAQ,EAAE,OAAO,CAAA;IACjB,UAAU,CAAC,EAAE,MAAM,CAAA;CACpB;AAED;;GAEG;AACH,wBAAgB,qBAAqB,IAAI,WAAW,CAcnD;AAED;;GAEG;AACH,wBAAgB,sBAAsB,IAAI,iBAAiB,CAsB1D;AAED;;GAEG;AACH,wBAAgB,aAAa,IAAI,WAAW,CAc3C;AAID;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,GAAE,MAAa,GAAG,OAAO,CAgC/D;AAED;;GAEG;AACH,wBAAgB,iBAAiB,IAAI,IAAI,CAMxC"}

package/dist/utils/service-detection.js

@@ -0,0 +1,103 @@
+import { readFileSync, existsSync } from 'fs';
+import { join } from 'path';
+import { spawn } from 'child_process';
+/**
+ * Auto-detect package.json for service name and version
+ */
+export function autoDetectPackageInfo() {
+    try {
+        const pkgPath = join(process.cwd(), 'package.json');
+        if (existsSync(pkgPath)) {
+            const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+            return {
+                name: pkg.name || 'unknown',
+                version: pkg.version || '0.0.0',
+            };
+        }
+    }
+    catch (error) {
+        // Ignore errors
+    }
+    return { name: 'unknown', version: '0.0.0' };
+}
+/**
+ * Auto-detect integrations from environment variables
+ */
+export function autoDetectIntegrations() {
+    const integrations = {};
+    // Common database env vars
+    const dbKeys = ['DATABASE_URL', 'DB_URL', 'POSTGRES_URL', 'MYSQL_URL', 'MONGODB_URL'];
+    for (const key of dbKeys) {
+        if (process.env[key]) {
+            integrations.database = process.env[key];
+            break;
+        }
+    }
+    // Common redis env vars
+    const redisKeys = ['REDIS_URL', 'CACHE_URL', 'UPSTASH_REDIS_URL'];
+    for (const key of redisKeys) {
+        if (process.env[key]) {
+            integrations.redis = process.env[key];
+            break;
+        }
+    }
+    return integrations;
+}
+/**
+ * Detect Drizzle configuration
+ */
+export function detectDrizzle() {
+    const possiblePaths = [
+        'drizzle.config.ts',
+        'drizzle.config.js',
+        'drizzle.config.mjs',
+    ];
+    for (const path of possiblePaths) {
+        if (existsSync(path)) {
+            return { detected: true, configPath: path };
+        }
+    }
+    return { detected: false };
+}
+let drizzleStudioProcess = null;
+/**
+ * Start Drizzle Studio
+ */
+export function startDrizzleStudio(port = 4983) {
+    const drizzleInfo = detectDrizzle();
+    if (!drizzleInfo.detected) {
+        console.warn('⚠️  Drizzle config not found. Skipping Drizzle Studio auto-start.');
+        return false;
+    }
+    console.log(`🗄️  Starting Drizzle Studio on port ${port}...`);
+    try {
+        drizzleStudioProcess = spawn('npx', ['drizzle-kit', 'studio', '--port', String(port), '--host', '0.0.0.0'], {
+            stdio: 'inherit',
+            detached: false,
+        });
+        drizzleStudioProcess.on('error', (error) => {
+            console.error('❌ Failed to start Drizzle Studio:', error.message);
+        });
+        drizzleStudioProcess.on('exit', (code) => {
+            if (code !== 0 && code !== null) {
+                console.error(`❌ Drizzle Studio exited with code ${code}`);
+            }
+        });
+        console.log(`✅ Drizzle Studio started`);
+        return true;
+    }
+    catch (error) {
+        console.error('❌ Failed to start Drizzle Studio:', error);
+        return false;
+    }
+}
+/**
+ * Stop Drizzle Studio
+ */
+export function stopDrizzleStudio() {
+    if (drizzleStudioProcess) {
+        drizzleStudioProcess.kill();
+        drizzleStudioProcess = null;
+        console.log('🛑 Drizzle Studio stopped');
+    }
+}

package/dist/utils/zod-utils.d.ts

@@ -0,0 +1,7 @@
+import type { ZodType } from 'zod';
+import type { RequestBodySchema } from '../types/index';
+/**
+ * Generate JSON template with comments from Zod schema
+ */
+export declare function generateZodTemplate(schema: ZodType): RequestBodySchema | undefined;
+//# sourceMappingURL=zod-utils.d.ts.map

package/dist/utils/zod-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zod-utils.d.ts","sourceRoot":"","sources":["../../src/utils/zod-utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAc,MAAM,KAAK,CAAA;AAC9C,OAAO,KAAK,EAAE,iBAAiB,EAAe,MAAM,gBAAgB,CAAA;AAEpE;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,OAAO,GAAG,iBAAiB,GAAG,SAAS,CAalF"}

package/dist/utils/zod-utils.js

@@ -0,0 +1,145 @@
+/**
+ * Generate JSON template with comments from Zod schema
+ */
+export function generateZodTemplate(schema) {
+    try {
+        const fields = extractZodFields(schema);
+        const template = generateJsonTemplate(fields);
+        return {
+            template,
+            fields,
+        };
+    }
+    catch (error) {
+        console.warn('Failed to generate template from Zod schema:', error);
+        return undefined;
+    }
+}
+/**
+ * Extract fields from Zod schema (supports v3 and v4)
+ */
+function extractZodFields(schema, path = []) {
+    const fields = [];
+    // Support both v3 (_def) and v4 (def)
+    const def = schema.def || schema._def;
+    if (!def)
+        return fields;
+    // Unwrap ZodOptional, ZodNullable, ZodDefault - not needed for top level object
+    let unwrapped = schema;
+    const currentDef = unwrapped.def || unwrapped._def;
+    const typeName = currentDef?.type || currentDef?.typeName;
+    if (typeName === 'object' || typeName === 'ZodObject') {
+        // Get shape - it can be a function (getter) or direct object
+        const shapeValue = currentDef?.shape;
+        const shape = typeof shapeValue === 'function' ? shapeValue() : shapeValue;
+        for (const [key, value] of Object.entries(shape || {})) {
+            const fieldSchema = value;
+            const fieldDef = fieldSchema.def || fieldSchema._def;
+            const isOptional = fieldSchema.type === 'optional' ||
+                fieldDef?.type === 'optional' ||
+                fieldDef?.typeName === 'ZodOptional' ||
+                fieldDef?.typeName === 'ZodDefault';
+            // Get description - might be in wrapped schema for optional fields
+            let description = fieldDef?.description || fieldSchema.description;
+            if (!description && fieldDef?.wrapped) {
+                const wrappedDef = fieldDef.wrapped.def || fieldDef.wrapped._def;
+                description = wrappedDef?.description || fieldDef.wrapped.description;
+            }
+            // Determine type
+            let fieldType = getZodType(fieldSchema);
+            // Check for nested objects/arrays
+            const nested = extractZodFields(fieldSchema, [...path, key]);
+            fields.push({
+                name: key,
+                type: fieldType,
+                description,
+                required: !isOptional,
+                nested: nested.length > 0 ? nested : undefined,
+                example: getZodExample(fieldSchema, fieldType),
+            });
+        }
+    }
+    return fields;
+}
+/**
+ * Get Zod type as string (supports v3 and v4)
+ */
+function getZodType(schema) {
+    let unwrapped = schema;
+    let def = unwrapped.def || unwrapped._def;
+    // Unwrap optional/nullable/default
+    while (def?.type === 'optional' ||
+        def?.type === 'nullable' ||
+        def?.type === 'default' ||
+        def?.typeName === 'ZodOptional' ||
+        def?.typeName === 'ZodNullable' ||
+        def?.typeName === 'ZodDefault') {
+        unwrapped = def?.innerType || def?.wrapped || unwrapped;
+        def = unwrapped.def || unwrapped._def;
+    }
+    // Support both v4 (type) and v3 (typeName)
+    const typeName = def?.type || def?.typeName || unwrapped.type;
+    switch (typeName) {
+        case 'string':
+        case 'ZodString':
+            return 'string';
+        case 'number':
+        case 'ZodNumber':
+            return 'number';
+        case 'boolean':
+        case 'ZodBoolean':
+            return 'boolean';
+        case 'array':
+        case 'ZodArray':
+            return 'array';
+        case 'object':
+        case 'ZodObject':
+            return 'object';
+        case 'enum':
+        case 'ZodEnum':
+            return 'enum';
+        case 'date':
+        case 'ZodDate':
+            return 'date';
+        default:
+            return 'any';
+    }
+}
+/**
+ * Get example value for Zod type
+ */
+function getZodExample(_schema, type) {
+    switch (type) {
+        case 'string': return '';
+        case 'number': return 0;
+        case 'boolean': return false;
+        case 'array': return [];
+        case 'object': return {};
+        default: return null;
+    }
+}
+/**
+ * Generate JSONC template with comments
+ */
+function generateJsonTemplate(fields, indent = 0) {
+    const lines = [];
+    const spacing = '  '.repeat(indent);
+    lines.push('{');
+    fields.forEach((field, index) => {
+        const isLast = index === fields.length - 1;
+        const description = field.description || field.name;
+        // Add comment
+        lines.push(`${spacing}  // ${description}`);
+        // Add field
+        let value;
+        if (field.nested && field.nested.length > 0) {
+            value = generateJsonTemplate(field.nested, indent + 1);
+        }
+        else {
+            value = JSON.stringify(field.example);
+        }
+        lines.push(`${spacing}  "${field.name}": ${value}${isLast ? '' : ','}`);
+    });
+    lines.push(`${spacing}}`);
+    return lines.join('\n');
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getvision/core",
-  "version": "0.0.0",
+  "version": "0.0.1",
   "type": "module",
   "exports": {
     ".": "./src/index.ts",