admindb 2.4.1 → 2.6.0

package/dist/modules/schema/schema.service.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SchemaService = void 0;
+class SchemaService {
+    static async getSchema(ctx, table) {
+        const r = await ctx.db.getSchema(table);
+        if (!r.success || !r.data)
+            throw new Error(r.error ?? 'Failed to load schema.');
+        return r.data;
+    }
+    static async getReferencingTables(ctx, table) {
+        const r = await ctx.db.getReferencingTables(table);
+        if (!r.success || !r.data)
+            throw new Error(r.error ?? 'Failed to get referencing tables.');
+        return r.data;
+    }
+    static async addColumn(ctx, table, col) {
+        if (!col?.name)
+            throw new Error('Column name is required.');
+        const r = await ctx.db.addColumn(table, col);
+        if (!r.success)
+            throw new Error(r.error ?? 'Failed to add column.');
+    }
+    static async modifyColumn(ctx, table, colName, col) {
+        if (!col)
+            throw new Error('Column definition is required.');
+        const r = await ctx.db.modifyColumn(table, colName, col);
+        if (!r.success)
+            throw new Error(r.error ?? 'Failed to modify column.');
+    }
+    static async renameColumn(ctx, table, colName, newName) {
+        const trimmed = String(newName ?? '').trim();
+        if (!trimmed)
+            throw new Error('New column name is required.');
+        const r = await ctx.db.renameColumn(table, colName, trimmed);
+        if (!r.success)
+            throw new Error(r.error ?? 'Failed to rename column.');
+    }
+    static async dropColumn(ctx, table, colName) {
+        const r = await ctx.db.dropColumn(table, colName);
+        if (!r.success)
+            throw new Error(r.error ?? 'Failed to drop column.');
+    }
+    static async createIndex(ctx, table, def) {
+        if (!def || !Array.isArray(def.columns) || def.columns.length === 0) {
+            throw new Error('At least one column is required for an index.');
+        }
+        const r = await ctx.db.createIndex(table, def);
+        if (!r.success)
+            throw new Error(r.error ?? 'Failed to create index.');
+    }
+    static async dropIndex(ctx, indexName) {
+        const r = await ctx.db.dropIndex(indexName);
+        if (!r.success)
+            throw new Error(r.error ?? 'Failed to drop index.');
+    }
+}
+exports.SchemaService = SchemaService;

package/dist/modules/search/index.d.ts

@@ -0,0 +1 @@
+export * from './search.types';export * from './search.service';export * from './search.routes';

package/dist/modules/search/index.js

@@ -0,0 +1,19 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./search.types"), exports);
+__exportStar(require("./search.service"), exports);
+__exportStar(require("./search.routes"), exports);

package/dist/modules/search/search.routes.d.ts

@@ -0,0 +1 @@
+import type {Router} from 'express';import{type RouteContext} from '../../core/router';export declare function registerSearchRoutes(router:Router,ctx:RouteContext):void;

package/dist/modules/search/search.routes.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerSearchRoutes = registerSearchRoutes;
+const router_1 = require("../../core/router");
+const search_service_1 = require("./search.service");
+function registerSearchRoutes(router, ctx) {
+    router.get('/api/search/:db', (0, router_1.wrap)(async (req, res) => {
+        const db = ctx.getContext(req);
+        const query = String(req.query.q ?? '');
+        const type = req.query.type ? String(req.query.type) : undefined;
+        const limit = req.query.limit ? parseInt(String(req.query.limit), 10) : 50;
+        const includeRows = req.query.includeRows !== 'false';
+        const basePath = String(res.locals.basePath ?? '');
+        try {
+            const results = await search_service_1.SearchService.search(db, query, {
+                type,
+                limit,
+                includeRows,
+                basePath,
+            });
+            (0, router_1.ok)(res, results);
+        }
+        catch (err) {
+            (0, router_1.fail)(res, err.message ?? 'Failed to execute global search.', 500);
+        }
+    }));
+    router.get('/api/search/:db/metadata', (0, router_1.wrap)(async (req, res) => {
+        const db = ctx.getContext(req);
+        const basePath = String(res.locals.basePath ?? '');
+        try {
+            const index = await search_service_1.SearchService.getMetadataIndex(db, basePath);
+            (0, router_1.ok)(res, index);
+        }
+        catch (err) {
+            (0, router_1.fail)(res, err.message ?? 'Failed to fetch search metadata.', 500);
+        }
+    }));
+}

package/dist/modules/search/search.service.d.ts

@@ -0,0 +1 @@
+import type {DatabaseContext} from '../../core/context';import type {SearchOptions,SearchResponse,SearchMetadataIndex,CommandItem} from './search.types';export declare class SearchService{static getCommands(dbId:string,basePath?:string,isReadOnly?:boolean):CommandItem[];static getMetadataIndex(ctx:DatabaseContext,basePath?:string):Promise<SearchMetadataIndex>;private static calculateScore;static search(ctx:DatabaseContext,rawQuery:string,options?:SearchOptions):Promise<SearchResponse>;private static searchRowData;}

package/dist/modules/search/search.service.js

@@ -0,0 +1,458 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SearchService = void 0;
+const generator_1 = require("../../sql/generator");
+class SearchService {
+    static getCommands(dbId, basePath = '', isReadOnly = false) {
+        const encDb = encodeURIComponent(dbId);
+        const commands = [
+            {
+                id: 'cmd-query',
+                title: 'New SQL Query',
+                description: 'Open the SQL query editor to run queries and scripts',
+                icon: 'query',
+                url: `${basePath}/query/${encDb}`,
+                keywords: ['sql', 'query', 'editor', 'execute', 'run', 'select', 'terminal'],
+            },
+            {
+                id: 'cmd-erd',
+                title: 'Entity Relationship Diagram',
+                description: 'Visualize database tables, relationships, and schema graph',
+                icon: 'diagram',
+                url: `${basePath}/erd/${encDb}`,
+                keywords: ['erd', 'diagram', 'graph', 'schema', 'relations', 'visualize', 'foreign keys'],
+            },
+            {
+                id: 'cmd-seed',
+                title: 'Seed Data Generator',
+                description: 'Generate relational mock and seed data with intelligent heuristics',
+                icon: 'seed',
+                url: `${basePath}/seed/${encDb}`,
+                keywords: ['seed', 'mock', 'fake data', 'generator', 'faker', 'synthetic data'],
+            },
+            {
+                id: 'cmd-diff',
+                title: 'Diff & Replicate Database',
+                description: 'Compare schemas, generate migration patches, or clone data',
+                icon: 'diff',
+                url: `${basePath}/diff/${encDb}`,
+                keywords: ['diff', 'sync', 'replicate', 'migrate', 'migration', 'patch', 'clone', 'compare'],
+            },
+            {
+                id: 'cmd-info',
+                title: 'Database Info & Settings',
+                description: 'View database pragma, engine configuration, and metadata',
+                icon: 'settings',
+                url: `${basePath}/info/${encDb}`,
+                keywords: ['info', 'settings', 'config', 'pragma', 'driver', 'version', 'database info'],
+            },
+            {
+                id: 'cmd-export',
+                title: 'Export Database (SQL Dump)',
+                description: 'Download full database schema and data as an SQL script',
+                icon: 'export',
+                url: `${basePath}/export/${encDb}`,
+                keywords: ['export', 'dump', 'backup', 'download', 'sql dump', 'save'],
+            },
+            {
+                id: 'cmd-home',
+                title: 'Database Dashboard',
+                description: 'Overview of all tables, total rows, and statistics',
+                icon: 'home',
+                url: `${basePath}/home/${encDb}`,
+                keywords: ['home', 'dashboard', 'overview', 'tables', 'stats'],
+            },
+        ];
+        if (!isReadOnly) {
+            commands.push({
+                id: 'cmd-designer',
+                title: 'Create New Table',
+                description: 'Design and create a new database table with custom columns and keys',
+                icon: 'plus',
+                url: `${basePath}/designer/${encDb}`,
+                keywords: ['create table', 'designer', 'new table', 'add table', 'schema designer'],
+            });
+        }
+        return commands;
+    }
+    static async getMetadataIndex(ctx, basePath = '') {
+        const listRes = await ctx.db.listTables();
+        const tableItems = listRes.success && listRes.data ? listRes.data : [];
+        const tables = [];
+        const columns = [];
+        const indexes = [];
+        const foreignKeys = [];
+        await Promise.all(tableItems.map(async (t) => {
+            const tableName = t.name;
+            try {
+                const infoRes = await ctx.db.getTableInfo(tableName);
+                if (!infoRes.success || !infoRes.data)
+                    return;
+                const info = infoRes.data;
+                tables.push({
+                    name: tableName,
+                    columnsCount: info.columns.length,
+                    primaryKey: info.primaryKey || [],
+                });
+                for (const col of info.columns) {
+                    const fk = (info.foreignKeys || []).find((f) => f.from === col.name);
+                    columns.push({
+                        table: tableName,
+                        name: col.name,
+                        type: col.type || 'TEXT',
+                        isPk: Boolean(col.pk),
+                        isFk: Boolean(fk),
+                        fkTarget: fk ? `${fk.table}.${fk.to || 'id'}` : null,
+                        notnull: Boolean(col.notnull),
+                        dflt_value: col.dflt_value,
+                    });
+                }
+                for (const idx of info.indexes || []) {
+                    indexes.push({
+                        table: tableName,
+                        name: idx.name,
+                        unique: Boolean(idx.unique),
+                        columns: idx.columns || [],
+                    });
+                }
+                for (const fk of info.foreignKeys || []) {
+                    foreignKeys.push({
+                        fromTable: tableName,
+                        fromColumn: fk.from,
+                        toTable: fk.table,
+                        toColumn: fk.to || null,
+                        onUpdate: fk.on_update || 'NO ACTION',
+                        onDelete: fk.on_delete || 'NO ACTION',
+                    });
+                }
+            }
+            catch {
+            }
+        }));
+        const commands = this.getCommands(ctx.name, basePath, ctx.isReadOnly || ctx.db.isReadOnly);
+        return {
+            tables,
+            columns,
+            indexes,
+            foreignKeys,
+            commands,
+        };
+    }
+    static calculateScore(target, query) {
+        if (!target || !query)
+            return 0;
+        const t = target.toLowerCase();
+        const q = query.toLowerCase();
+        if (t === q)
+            return 100;
+        if (t.startsWith(q))
+            return 85;
+        if (t.includes(`_${q}`) || t.includes(`-${q}`) || t.includes(`.${q}`) || t.includes(` ${q}`))
+            return 75;
+        if (t.includes(q))
+            return 50;
+        let qIdx = 0;
+        for (let i = 0; i < t.length && qIdx < q.length; i++) {
+            if (t[i] === q[qIdx])
+                qIdx++;
+        }
+        if (qIdx === q.length)
+            return 25;
+        return 0;
+    }
+    static async search(ctx, rawQuery, options = {}) {
+        const q = String(rawQuery ?? '').trim();
+        const basePath = options.basePath ?? '';
+        const type = options.type ? options.type.toLowerCase() : 'all';
+        const limit = options.limit && options.limit > 0 ? options.limit : 50;
+        const includeRows = options.includeRows !== false;
+        const encDb = encodeURIComponent(ctx.name);
+        const metadata = await this.getMetadataIndex(ctx, basePath);
+        const results = [];
+        const shouldSearch = (category) => {
+            if (type === 'all')
+                return true;
+            if (type === 'tables' || type === 'table')
+                return category === 'table';
+            if (type === 'columns' || type === 'column')
+                return category === 'column';
+            if (type === 'indexes' || type === 'index')
+                return category === 'index';
+            if (type === 'relations' || type === 'relation' || type === 'foreignkeys')
+                return category === 'relation';
+            if (type === 'commands' || type === 'command')
+                return category === 'command';
+            if (type === 'rows' || type === 'row' || type === 'data')
+                return category === 'row';
+            return false;
+        };
+        if (shouldSearch('table')) {
+            for (const table of metadata.tables) {
+                const score = q ? this.calculateScore(table.name, q) : 50;
+                if (score > 0 || !q) {
+                    const encTable = encodeURIComponent(table.name);
+                    results.push({
+                        id: `tbl-${table.name}`,
+                        category: 'table',
+                        title: table.name,
+                        subtitle: `Table · ${table.columnsCount} columns${table.primaryKey.length ? ` · PK (${table.primaryKey.join(', ')})` : ''}`,
+                        icon: 'table',
+                        url: `${basePath}/tables/${encDb}/${encTable}`,
+                        score: score + 15,
+                        badge: 'Table',
+                        badgeType: 'primary',
+                        actions: [
+                            { label: 'Browse', url: `${basePath}/tables/${encDb}/${encTable}`, primary: true },
+                            { label: 'Schema', url: `${basePath}/schema/${encDb}/${encTable}` },
+                            { label: 'Query', url: `${basePath}/query/${encDb}?sql=${encodeURIComponent(`SELECT * FROM ${table.name} LIMIT 100;`)}` },
+                        ],
+                        metadata: {
+                            table: table.name,
+                            columnsCount: table.columnsCount,
+                            primaryKey: table.primaryKey,
+                        },
+                    });
+                }
+            }
+        }
+        if (shouldSearch('column')) {
+            for (const col of metadata.columns) {
+                let score = 0;
+                if (q) {
+                    const nameScore = this.calculateScore(col.name, q);
+                    const fullScore = this.calculateScore(`${col.table}.${col.name}`, q);
+                    const typeScore = this.calculateScore(col.type, q) > 70 ? 40 : 0;
+                    score = Math.max(nameScore, fullScore, typeScore);
+                }
+                else {
+                    score = 30;
+                }
+                if (score > 0 || !q) {
+                    const encTable = encodeURIComponent(col.table);
+                    const pkTag = col.isPk ? ' · Primary Key' : '';
+                    const fkTag = col.isFk ? ` · FK → ${col.fkTarget}` : '';
+                    const nullTag = col.notnull ? ' · NOT NULL' : '';
+                    const dfltTag = col.dflt_value ? ` · default ${col.dflt_value}` : '';
+                    results.push({
+                        id: `col-${col.table}-${col.name}`,
+                        category: 'column',
+                        title: col.name,
+                        subtitle: `${col.table} · ${col.type}${pkTag}${fkTag}${nullTag}${dfltTag}`,
+                        icon: 'columns',
+                        url: `${basePath}/tables/${encDb}/${encTable}`,
+                        score: score + 10,
+                        badge: col.isPk ? 'PK' : col.isFk ? 'FK' : col.type,
+                        badgeType: col.isPk ? 'accent' : col.isFk ? 'info' : 'neutral',
+                        actions: [
+                            { label: 'Browse Table', url: `${basePath}/tables/${encDb}/${encTable}`, primary: true },
+                            { label: 'View Schema', url: `${basePath}/schema/${encDb}/${encTable}` },
+                        ],
+                        metadata: {
+                            table: col.table,
+                            column: col.name,
+                            type: col.type,
+                            isPk: col.isPk,
+                            isFk: col.isFk,
+                            fkTarget: col.fkTarget,
+                        },
+                    });
+                }
+            }
+        }
+        if (shouldSearch('index')) {
+            for (const idx of metadata.indexes) {
+                let score = 0;
+                if (q) {
+                    const nameScore = this.calculateScore(idx.name, q);
+                    const colsScore = idx.columns.some((c) => this.calculateScore(c, q) > 60) ? 60 : 0;
+                    score = Math.max(nameScore, colsScore);
+                }
+                else {
+                    score = 25;
+                }
+                if (score > 0 || !q) {
+                    const encTable = encodeURIComponent(idx.table);
+                    results.push({
+                        id: `idx-${idx.table}-${idx.name}`,
+                        category: 'index',
+                        title: idx.name,
+                        subtitle: `${idx.table} (${idx.columns.join(', ')}) · ${idx.unique ? 'UNIQUE ' : ''}Index`,
+                        icon: 'key',
+                        url: `${basePath}/schema/${encDb}/${encTable}`,
+                        score,
+                        badge: idx.unique ? 'Unique Index' : 'Index',
+                        badgeType: idx.unique ? 'warning' : 'neutral',
+                        actions: [
+                            { label: 'View in Schema', url: `${basePath}/schema/${encDb}/${encTable}`, primary: true },
+                            { label: 'Browse Table', url: `${basePath}/tables/${encDb}/${encTable}` },
+                        ],
+                        metadata: {
+                            table: idx.table,
+                            index: idx.name,
+                            unique: idx.unique,
+                            columns: idx.columns,
+                        },
+                    });
+                }
+            }
+        }
+        if (shouldSearch('relation')) {
+            for (const fk of metadata.foreignKeys) {
+                let score = 0;
+                if (q) {
+                    const fromScore = this.calculateScore(`${fk.fromTable}.${fk.fromColumn}`, q);
+                    const toScore = this.calculateScore(`${fk.toTable}.${fk.toColumn || 'id'}`, q);
+                    score = Math.max(fromScore, toScore);
+                }
+                else {
+                    score = 25;
+                }
+                if (score > 0 || !q) {
+                    const fromEnc = encodeURIComponent(fk.fromTable);
+                    results.push({
+                        id: `fk-${fk.fromTable}-${fk.fromColumn}-${fk.toTable}`,
+                        category: 'relation',
+                        title: `${fk.fromTable}.${fk.fromColumn} → ${fk.toTable}.${fk.toColumn || 'id'}`,
+                        subtitle: `Foreign Key · ON UPDATE ${fk.onUpdate}, ON DELETE ${fk.onDelete}`,
+                        icon: 'diagram',
+                        url: `${basePath}/erd/${encDb}`,
+                        score,
+                        badge: 'Relation',
+                        badgeType: 'info',
+                        actions: [
+                            { label: 'View ERD', url: `${basePath}/erd/${encDb}`, primary: true },
+                            { label: `Browse ${fk.fromTable}`, url: `${basePath}/tables/${encDb}/${fromEnc}` },
+                        ],
+                        metadata: {
+                            fromTable: fk.fromTable,
+                            fromColumn: fk.fromColumn,
+                            toTable: fk.toTable,
+                            toColumn: fk.toColumn,
+                        },
+                    });
+                }
+            }
+        }
+        if (shouldSearch('command')) {
+            for (const cmd of metadata.commands) {
+                let score = 0;
+                if (q) {
+                    const titleScore = this.calculateScore(cmd.title, q);
+                    const descScore = this.calculateScore(cmd.description, q) > 70 ? 40 : 0;
+                    const kwScore = cmd.keywords.some((k) => this.calculateScore(k, q) > 70) ? 70 : 0;
+                    score = Math.max(titleScore, descScore, kwScore);
+                }
+                else {
+                    score = 45;
+                }
+                if (score > 0 || !q) {
+                    results.push({
+                        id: cmd.id,
+                        category: 'command',
+                        title: cmd.title,
+                        subtitle: cmd.description,
+                        icon: cmd.icon,
+                        url: cmd.url,
+                        score: score + 5,
+                        badge: 'Command',
+                        badgeType: 'secondary',
+                        actions: [{ label: 'Execute', url: cmd.url, primary: true }],
+                        metadata: {
+                            keywords: cmd.keywords,
+                        },
+                    });
+                }
+            }
+        }
+        if (q.length >= 2 && includeRows && shouldSearch('row')) {
+            try {
+                const rowResults = await this.searchRowData(ctx, q, metadata.tables, metadata.columns, basePath, limit);
+                results.push(...rowResults);
+            }
+            catch {
+            }
+        }
+        results.sort((a, b) => b.score - a.score);
+        const categoryCounts = {
+            table: 0,
+            column: 0,
+            index: 0,
+            relation: 0,
+            command: 0,
+            row: 0,
+        };
+        for (const r of results) {
+            categoryCounts[r.category] = (categoryCounts[r.category] || 0) + 1;
+        }
+        const slicedResults = results.slice(0, limit);
+        return {
+            query: q,
+            total: results.length,
+            categories: categoryCounts,
+            results: slicedResults,
+        };
+    }
+    static async searchRowData(ctx, query, tables, columns, basePath, limit) {
+        const rowResults = [];
+        const encDb = encodeURIComponent(ctx.name);
+        const maxTablesToSearch = 12;
+        const maxRowsPerTable = 3;
+        const searchableTables = tables.slice(0, maxTablesToSearch);
+        for (const table of searchableTables) {
+            if (rowResults.length >= limit)
+                break;
+            const textCols = columns.filter((c) => c.table === table.name &&
+                /(text|char|varchar|nvarchar|string|clob|json|blob)/i.test(c.type || 'TEXT'));
+            if (textCols.length === 0)
+                continue;
+            const colNames = textCols.map((c) => c.name);
+            const whereClauses = colNames.map((c) => `${(0, generator_1.quoteIdentifier)(c)} LIKE ?`).join(' OR ');
+            const params = colNames.map(() => `%${query}%`);
+            const selectSql = `SELECT rowid AS _rowid_, * FROM ${(0, generator_1.quoteIdentifier)(table.name)} WHERE ${whereClauses} LIMIT ${maxRowsPerTable}`;
+            try {
+                const res = await ctx.db.all(selectSql, params);
+                if (res.success && Array.isArray(res.data)) {
+                    for (const row of res.data) {
+                        let matchedCol = colNames[0];
+                        let matchedVal = '';
+                        for (const colName of colNames) {
+                            const val = String(row[colName] ?? '');
+                            if (val.toLowerCase().includes(query.toLowerCase())) {
+                                matchedCol = colName;
+                                matchedVal = val;
+                                break;
+                            }
+                        }
+                        const snippet = matchedVal.length > 80 ? `${matchedVal.slice(0, 80)}…` : matchedVal;
+                        const rowId = row._rowid_ ?? row.id ?? row[table.primaryKey[0]] ?? '';
+                        const encTable = encodeURIComponent(table.name);
+                        rowResults.push({
+                            id: `row-${table.name}-${rowId}-${matchedCol}`,
+                            category: 'row',
+                            title: `${table.name}${rowId ? ` #${rowId}` : ''}: ${matchedCol} = "${snippet}"`,
+                            subtitle: `Row data match in ${table.name}.${matchedCol}`,
+                            icon: 'inspect',
+                            url: `${basePath}/tables/${encDb}/${encTable}`,
+                            score: 35,
+                            badge: 'Row Data',
+                            badgeType: 'neutral',
+                            actions: [
+                                { label: 'Browse Table', url: `${basePath}/tables/${encDb}/${encTable}`, primary: true },
+                            ],
+                            metadata: {
+                                table: table.name,
+                                column: matchedCol,
+                                value: snippet,
+                                row,
+                            },
+                        });
+                    }
+                }
+            }
+            catch {
+            }
+        }
+        return rowResults;
+    }
+}
+exports.SearchService = SearchService;

package/dist/modules/search/search.types.d.ts

@@ -0,0 +1 @@
+export type SearchCategory='table'|'column'|'index'|'relation'|'command'|'row';export interface SearchAction{label:string;url:string;icon?:string;primary?:boolean;}export interface SearchItem{id:string;category:SearchCategory;title:string;subtitle:string;icon:string;url:string;score:number;badge?:string;badgeType?:'primary'|'secondary'|'accent'|'info'|'success'|'warning'|'error'|'neutral';actions?:SearchAction[];metadata?:Record<string,unknown>;}export interface SearchResponse{query:string;total:number;categories:Record<SearchCategory,number>;results:SearchItem[];}export interface SearchOptions{query?:string;type?:string;limit?:number;includeRows?:boolean;basePath?:string;}export interface TableSummary{name:string;columnsCount:number;rowCount?:number;primaryKey:string[];}export interface ColumnSummary{table:string;name:string;type:string;isPk:boolean;isFk:boolean;fkTarget?:string|null;notnull:boolean;dflt_value:string|null;}export interface IndexSummary{table:string;name:string;unique:boolean;columns:string[];}export interface ForeignKeySummary{fromTable:string;fromColumn:string;toTable:string;toColumn:string|null;onUpdate:string;onDelete:string;}export interface CommandItem{id:string;title:string;description:string;icon:string;url:string;keywords:string[];shortcut?:string;}export interface SearchMetadataIndex{tables:TableSummary[];columns:ColumnSummary[];indexes:IndexSummary[];foreignKeys:ForeignKeySummary[];commands:CommandItem[];}

package/dist/modules/search/search.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/modules/seed/index.d.ts

@@ -0,0 +1 @@
+export * from './seed.service';export * from './seed.routes';

package/dist/modules/seed/index.js

@@ -0,0 +1,18 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./seed.service"), exports);
+__exportStar(require("./seed.routes"), exports);

package/dist/modules/seed/seed.routes.d.ts

@@ -0,0 +1 @@
+import type {Router} from 'express';import{type RouteContext} from '../../core/router';export declare function registerSeedRoutes(router:Router,ctx:RouteContext):void;