feat(cli): ZenStack proxy

packages/cli/package.json

@@ -38,30 +38,37 @@
     "dependencies": {
         "@zenstackhq/common-helpers": "workspace:*",
         "@zenstackhq/language": "workspace:*",
+        "@zenstackhq/orm": "workspace:*",
         "@zenstackhq/sdk": "workspace:*",
+        "@zenstackhq/server": "workspace:*",
+        "better-sqlite3": "catalog:",
         "chokidar": "^5.0.0",
         "colors": "1.4.0",
         "commander": "^8.3.0",
+        "cors": "^2.8.5",
         "execa": "^9.6.0",
+        "express": "^5.0.0",
         "jiti": "^2.6.1",
         "langium": "catalog:",
         "mixpanel": "^0.18.1",
         "ora": "^5.4.1",
         "package-manager-detector": "^1.3.0",
+        "pg": "catalog:",
         "prisma": "catalog:",
         "semver": "^7.7.2",
         "ts-pattern": "catalog:"
     },
     "devDependencies": {
         "@types/better-sqlite3": "catalog:",
+        "@types/cors": "^2.8.19",
+        "@types/express": "^5.0.0",
+        "@types/pg": "^8.16.0",
         "@types/semver": "^7.7.0",
         "@types/tmp": "catalog:",
         "@zenstackhq/eslint-config": "workspace:*",
-        "@zenstackhq/orm": "workspace:*",
         "@zenstackhq/testtools": "workspace:*",
         "@zenstackhq/typescript-config": "workspace:*",
         "@zenstackhq/vitest-config": "workspace:*",
-        "better-sqlite3": "catalog:",
         "tmp": "catalog:"
     },
     "engines": {

packages/cli/src/actions/action-utils.ts

@@ -144,3 +144,15 @@ export async function requireDataSourceUrl(schemaFile: string) {
         throw new CliError('The schema\'s "datasource" must have a "url" field to use this command.');
     }
 }
+
+export function getOutputPath(options: { output?: string }, schemaFile: string) {
+    if (options.output) {
+        return options.output;
+    }
+    const pkgJsonConfig = getPkgJsonConfig(process.cwd());
+    if (pkgJsonConfig.output) {
+        return pkgJsonConfig.output;
+    } else {
+        return path.dirname(schemaFile);
+    }
+}

packages/cli/src/actions/generate.ts

@@ -12,7 +12,7 @@ import { watch } from 'chokidar';
 import ora, { type Ora } from 'ora';
 import { CliError } from '../cli-error';
 import * as corePlugins from '../plugins';
-import { getPkgJsonConfig, getSchemaFile, loadSchemaDocument } from './action-utils';
+import { getOutputPath, getSchemaFile, loadSchemaDocument } from './action-utils';
 
 type Options = {
     schema?: string;
@@ -39,15 +39,16 @@ export async function run(options: Options) {
         const schemaExtensions = ZModelLanguageMetaData.fileExtensions;
 
         // Get real models file path (cuz its merged into single document -> we need use cst nodes)
-        const getRootModelWatchPaths = (model: Model) => new Set<string>(
-            (
-                model.declarations.filter(
-                    (v) =>
-                        v.$cstNode?.parent?.element.$type === 'Model' &&
-                        !!v.$cstNode.parent.element.$document?.uri?.fsPath,
-                ) as AbstractDeclaration[]
-            ).map((v) => v.$cstNode!.parent!.element.$document!.uri!.fsPath),
-        );
+        const getRootModelWatchPaths = (model: Model) =>
+            new Set<string>(
+                (
+                    model.declarations.filter(
+                        (v) =>
+                            v.$cstNode?.parent?.element.$type === 'Model' &&
+                            !!v.$cstNode.parent.element.$document?.uri?.fsPath,
+                    ) as AbstractDeclaration[]
+                ).map((v) => v.$cstNode!.parent!.element.$document!.uri!.fsPath),
+            );
 
         const watchedPaths = getRootModelWatchPaths(model);
 
@@ -64,40 +65,44 @@ export async function run(options: Options) {
         });
 
         // prevent save multiple files and run multiple times
-        const reGenerateSchema = singleDebounce(async () => {
-            if (logsEnabled) {
-                console.log('Got changes, run generation!');
-            }
+        const reGenerateSchema = singleDebounce(
+            async () => {
+                if (logsEnabled) {
+                    console.log('Got changes, run generation!');
+                }
 
-            try {
-                const newModel = await pureGenerate(options, true);
-                const allModelsPaths = getRootModelWatchPaths(newModel);
-                const newModelPaths = [...allModelsPaths].filter((at) => !watchedPaths.has(at));
-                const removeModelPaths = [...watchedPaths].filter((at) => !allModelsPaths.has(at));
+                try {
+                    const newModel = await pureGenerate(options, true);
+                    const allModelsPaths = getRootModelWatchPaths(newModel);
+                    const newModelPaths = [...allModelsPaths].filter((at) => !watchedPaths.has(at));
+                    const removeModelPaths = [...watchedPaths].filter((at) => !allModelsPaths.has(at));
 
-                if (newModelPaths.length) {
-                    if (logsEnabled) {
-                        const logPaths = newModelPaths.map((at) => `- ${at}`).join('\n');
-                        console.log(`Added file(s) to watch:\n${logPaths}`);
+                    if (newModelPaths.length) {
+                        if (logsEnabled) {
+                            const logPaths = newModelPaths.map((at) => `- ${at}`).join('\n');
+                            console.log(`Added file(s) to watch:\n${logPaths}`);
+                        }
+
+                        newModelPaths.forEach((at) => watchedPaths.add(at));
+                        watcher.add(newModelPaths);
                     }
 
-                    newModelPaths.forEach((at) => watchedPaths.add(at));
-                    watcher.add(newModelPaths);
-                }
+                    if (removeModelPaths.length) {
+                        if (logsEnabled) {
+                            const logPaths = removeModelPaths.map((at) => `- ${at}`).join('\n');
+                            console.log(`Removed file(s) from watch:\n${logPaths}`);
+                        }
 
-                if (removeModelPaths.length) {
-                    if (logsEnabled) {
-                        const logPaths = removeModelPaths.map((at) => `- ${at}`).join('\n');
-                        console.log(`Removed file(s) from watch:\n${logPaths}`);
+                        removeModelPaths.forEach((at) => watchedPaths.delete(at));
+                        watcher.unwatch(removeModelPaths);
                     }
-
-                    removeModelPaths.forEach((at) => watchedPaths.delete(at));
-                    watcher.unwatch(removeModelPaths);
+                } catch (e) {
+                    console.error(e);
                 }
-            } catch (e) {
-                console.error(e);
-            }
-        }, 500, true);
+            },
+            500,
+            true,
+        );
 
         watcher.on('unlink', (pathAt) => {
             if (logsEnabled) {
@@ -148,18 +153,6 @@ Check documentation: https://zenstack.dev/docs/`);
     return model;
 }
 
-function getOutputPath(options: Options, schemaFile: string) {
-    if (options.output) {
-        return options.output;
-    }
-    const pkgJsonConfig = getPkgJsonConfig(process.cwd());
-    if (pkgJsonConfig.output) {
-        return pkgJsonConfig.output;
-    } else {
-        return path.dirname(schemaFile);
-    }
-}
-
 async function runPlugins(schemaFile: string, model: Model, outputPath: string, options: Options) {
     const plugins = model.declarations.filter(isPlugin);
     const processedPlugins: { cliPlugin: CliPlugin; pluginOptions: Record<string, unknown> }[] = [];

packages/cli/src/actions/index.ts

@@ -6,5 +6,6 @@ import { run as info } from './info';
 import { run as init } from './init';
 import { run as migrate } from './migrate';
 import { run as seed } from './seed';
+import { run as proxy } from './proxy';
 
-export { check, db, format, generate, info, init, migrate, seed };
+export { check, db, format, generate, info, init, migrate, seed, proxy };

packages/cli/src/actions/proxy.ts

@@ -0,0 +1,177 @@
+import { isDataSource } from '@zenstackhq/language/ast';
+import { getOutputPath, getSchemaFile, loadSchemaDocument } from './action-utils';
+import { CliError } from '../cli-error';
+import { ZModelCodeGenerator } from '@zenstackhq/language';
+import { getStringLiteral } from '@zenstackhq/language/utils';
+import { SqliteDialect } from '@zenstackhq/orm/dialects/sqlite';
+import { PostgresDialect } from '@zenstackhq/orm/dialects/postgres';
+import SQLite from 'better-sqlite3';
+import { Pool } from 'pg';
+import path from 'node:path';
+import { ZenStackClient, type ClientContract } from '@zenstackhq/orm';
+import { RPCApiHandler } from '@zenstackhq/server/api';
+import { ZenStackMiddleware } from '@zenstackhq/server/express';
+import express from 'express';
+import colors from 'colors';
+import { createJiti } from 'jiti';
+import { getVersion } from '../utils/version-utils';
+import cors from 'cors';
+
+type Options = {
+    output?: string;
+    schema?: string;
+    port?: number;
+    logLevel?: string[];
+    databaseUrl?: string;
+};
+
+export async function run(options: Options) {
+    const schemaFile = getSchemaFile(options.schema);
+    console.log(colors.gray(`Loading ZModel schema from: ${schemaFile}`));
+
+    let outputPath = getOutputPath(options, schemaFile);
+
+    // Ensure outputPath is absolute
+    if (!path.isAbsolute(outputPath)) {
+        outputPath = path.resolve(process.cwd(), outputPath);
+    }
+
+    const model = await loadSchemaDocument(schemaFile);
+
+    const dataSource = model.declarations.find(isDataSource);
+
+    let databaseUrl = options.databaseUrl;
+
+    if (!databaseUrl) {
+        const schemaUrl = dataSource?.fields.find((f) => f.name === 'url')?.value;
+
+        if (!schemaUrl) {
+            throw new CliError(
+                `The schema's "datasource" does not have a "url" field, please provide it with -d option.`,
+            );
+        }
+        const zModelGenerator = new ZModelCodeGenerator();
+        const url = zModelGenerator.generate(schemaUrl);
+
+        databaseUrl = evaluateUrl(url);
+    }
+
+    const provider = getStringLiteral(dataSource?.fields.find((f) => f.name === 'provider')?.value)!;
+
+    const dialect = createDialect(provider, databaseUrl!, outputPath);
+
+    const jiti = createJiti(import.meta.url);
+
+    const schemaModule = (await jiti.import(path.join(outputPath, 'schema'))) as any;
+
+    const allowedLogLevels = ['error', 'query'] as const;
+    const log = options.logLevel?.filter((level): level is (typeof allowedLogLevels)[number] =>
+        allowedLogLevels.includes(level as any),
+    );
+
+    const db = new ZenStackClient(schemaModule.schema, {
+        dialect: dialect,
+        log: log && log.length > 0 ? log : undefined,
+    });
+
+    // check whether the database is reachable
+    try {
+        await db.$connect();
+    } catch (err) {
+        throw new CliError(`Failed to connect to the database: ${err instanceof Error ? err.message : String(err)}`);
+    }
+
+    startServer(db, schemaModule.schema, options);
+}
+
+function evaluateUrl(value: string): string {
+    // Create env helper function
+    const env = (varName: string) => {
+        const envValue = process.env[varName];
+        if (!envValue) {
+            throw new CliError(`Environment variable ${varName} is not set`);
+        }
+        return envValue;
+    };
+
+    try {
+        // Use Function constructor to evaluate the url value
+        const urlFn = new Function('env', `return ${value}`);
+        const url = urlFn(env);
+        return url;
+    } catch (err) {
+        if (err instanceof CliError) {
+            throw err;
+        }
+        throw new CliError('Could not evaluate datasource url from schema, you could provide it via -d option.');
+    }
+}
+
+function createDialect(provider: string, databaseUrl: string, outputPath: string) {
+    switch (provider) {
+        case 'sqlite': {
+            let resolvedUrl = databaseUrl.trim();
+            if (resolvedUrl.startsWith('file:')) {
+                const filePath = resolvedUrl.substring('file:'.length);
+                if (!path.isAbsolute(filePath)) {
+                    resolvedUrl = path.join(outputPath, filePath);
+                }
+            }
+            console.log(colors.gray(`Connecting to SQLite database at: ${resolvedUrl}`));
+            return new SqliteDialect({
+                database: new SQLite(resolvedUrl),
+            });
+        }
+        case 'postgresql':
+            console.log(colors.gray(`Connecting to PostgreSQL database at: ${databaseUrl}`));
+            return new PostgresDialect({
+                pool: new Pool({
+                    connectionString: databaseUrl,
+                }),
+            });
+        default:
+            throw new CliError(`Unsupported database provider: ${provider}`);
+    }
+}
+
+function startServer(client: ClientContract<any, any>, schema: any, options: Options) {
+    const app = express();
+    app.use(cors());
+    app.use(express.json({ limit: '5mb' }));
+    app.use(express.urlencoded({ extended: true, limit: '5mb' }));
+
+    app.use(
+        '/api/model',
+        ZenStackMiddleware({
+            apiHandler: new RPCApiHandler({ schema }),
+            getClient: () => client,
+        }),
+    );
+
+    app.get('/api/schema', (_req, res: express.Response) => {
+        res.json({ ...schema, zenstackVersion: getVersion() });
+    });
+
+    const server = app.listen(options.port, () => {
+        console.log(`ZenStack proxy server is running on port: ${options.port}`);
+        console.log(`You can visit ZenStack Studio at: ${colors.blue('https://studio.zenstack.dev')}`);
+    });
+
+    // Graceful shutdown
+    process.on('SIGTERM', async () => {
+        server.close(() => {
+            console.log('\nZenStack proxy server closed');
+        });
+
+        await client.$disconnect();
+        process.exit(0);
+    });
+
+    process.on('SIGINT', async () => {
+        server.close(() => {
+            console.log('\nZenStack proxy server closed');
+        });
+        await client.$disconnect();
+        process.exit(0);
+    });
+}