feat: add monorepo's entry

Author: cqh963852

packages/schema/package.json

@@ -69,6 +69,12 @@
                     "type": "boolean",
                     "default": true,
                     "description": "Search for Mermaid extensions when viewing Mermaid source."
+                },
+                "zmodel.entries": {
+                    "type": "array",
+                    "items": { "type": "string" },
+                    "default": [],
+                    "description": "Glob patterns for entry .zmodel files. When set, the language server will only treat matched files as entry schemas (e.g. [\"**/dbs/db1/schema.zmodel\",\"**/dbs/db2/schema.zmodel\"])."
                 }
             }
         },

packages/schema/src/language-server/zmodel-workspace-manager.ts

@@ -1,58 +1,82 @@
 import { isPlugin, Model } from '@zenstackhq/language/ast';
 import { getLiteral } from '@zenstackhq/sdk';
-import { DefaultWorkspaceManager, interruptAndCheck, LangiumDocument } from 'langium';
+import {
+    ConfigurationProvider,
+    DefaultWorkspaceManager,
+    interruptAndCheck,
+    LangiumDocument,
+    LangiumSharedServices,
+} from 'langium';
 import fs from 'fs';
 import path from 'path';
 import { CancellationToken, WorkspaceFolder } from 'vscode-languageserver';
 import { URI, Utils } from 'vscode-uri';
 import { PLUGIN_MODULE_NAME, STD_LIB_MODULE_NAME } from './constants';
+import { ZModelLanguageMetaData } from '@zenstackhq/language/generated/module';
 
 /**
  * Custom Langium WorkspaceManager implementation which automatically loads stdlib.zmodel
  */
 export class ZModelWorkspaceManager extends DefaultWorkspaceManager {
+    protected readonly configurationProvider: ConfigurationProvider;
+
+    constructor(services: LangiumSharedServices) {
+        super(services);
+
+        this.configurationProvider = services.workspace.ConfigurationProvider;
+    }
     public pluginModels = new Set<string>();
+    private entryDocumentUris: Set<string> = new Set();
+
+    public isEntryDocument(uri: string | URI): boolean {
+        const u = typeof uri === 'string' ? uri : uri.toString();
+        return this.entryDocumentUris.has(u);
+    }
+
+    public getEntryDocumentUris(): Set<string> {
+        return new Set(this.entryDocumentUris);
+    }
 
     protected async loadAdditionalDocuments(
         _folders: WorkspaceFolder[],
         _collector: (document: LangiumDocument) => void
     ): Promise<void> {
         await super.loadAdditionalDocuments(_folders, _collector);
-        
-        let stdLibPath: string;        
+
+        let stdLibPath: string;
         // First, try to find the stdlib from an installed zenstack package
         // in the project's node_modules
         let installedStdlibPath: string | undefined;
         for (const folder of _folders) {
             const folderPath = this.getRootFolder(folder).fsPath;
             try {
                 // Try to resolve zenstack from the workspace folder
-                const languagePackagePath = require.resolve('zenstack/package.json', { 
-                    paths: [folderPath] 
+                const languagePackagePath = require.resolve('zenstack/package.json', {
+                    paths: [folderPath],
                 });
                 const languagePackageDir = path.dirname(languagePackagePath);
                 const candidateStdlibPath = path.join(languagePackageDir, 'res', STD_LIB_MODULE_NAME);
-                
+
                 // Check if the stdlib file exists in the installed package
                 if (fs.existsSync(candidateStdlibPath)) {
                     installedStdlibPath = candidateStdlibPath;
                     console.log(`Found installed zenstack package stdlib at ${installedStdlibPath}`);
                     break;
-                } 
+                }
             } catch (error) {
                 // Package not found or other error, continue to next folder
                 continue;
             }
         }
-        
+
         if (installedStdlibPath) {
             stdLibPath = installedStdlibPath;
         } else {
             // Fallback to bundled stdlib
             stdLibPath = path.join(__dirname, '../res', STD_LIB_MODULE_NAME);
             console.log(`Using bundled stdlib in extension`);
         }
-        
+
         const stdLibUri = URI.file(stdLibPath);
         console.log(`Adding stdlib document from ${stdLibUri}`);
         const stdlib = this.langiumDocuments.getOrCreateDocument(stdLibUri);
@@ -112,6 +136,62 @@ export class ZModelWorkspaceManager extends DefaultWorkspaceManager {
             }
         }
 
+        // Save entry document URIs based on user configuration (simple mode: accept absolute file paths or file:// URIs)
+        try {
+            const entries = await this.configurationProvider.getConfiguration(
+                ZModelLanguageMetaData.languageId,
+                'entries'
+            );
+            const entryUris = new Set<string>();
+            if (Array.isArray(entries)) {
+                for (const e of entries) {
+                    if (typeof e !== 'string') continue;
+                    try {
+                        if (e.startsWith('file://')) {
+                            const u = URI.parse(e);
+                            entryUris.add(u.toString());
+                        } else if (path.isAbsolute(e)) {
+                            const u = URI.file(e);
+                            entryUris.add(u.toString());
+                        } else {
+                            // Try resolving relative entries against workspace folders
+                            let resolved = false;
+                            for (const wf of folders) {
+                                try {
+                                    const folderPath = this.getRootFolder(wf).fsPath;
+                                    const candidate = path.join(folderPath, e);
+                                    if (fs.existsSync(candidate)) {
+                                        const u = URI.file(candidate);
+                                        entryUris.add(u.toString());
+                                        resolved = true;
+                                        break;
+                                    }
+                                } catch {
+                                    // ignore and continue with other folders
+                                }
+                            }
+                            if (!resolved) {
+                                // ignore relative/glob entries that cannot be resolved in simple mode
+                                console.warn(
+                                    `zmodel.entries value ignored (not absolute/file URI/resolvable relative to workspace): ${e}`
+                                );
+                            }
+                        }
+                    } catch {
+                        console.warn(`Invalid zmodel.entries entry ignored: ${e}`);
+                    }
+                }
+            }
+            this.entryDocumentUris = entryUris;
+            if (this.entryDocumentUris.size > 0) {
+                console.log(
+                    `ZModelWorkspaceManager: using configured zmodel.entries: ${Array.from(this.entryDocumentUris)}`
+                );
+            }
+        } catch (err) {
+            console.warn('Failed to read zmodel.entries configuration:', err);
+        }
+
         // Only after creating all documents do we check whether we need to cancel the initialization
         // The document builder will later pick up on all unprocessed documents
         await interruptAndCheck(cancelToken);