@resolveio/server-lib 22.3.53 → 22.3.55

package/gulpfile.js

@@ -0,0 +1,216 @@
+var gulp = require("gulp");
+var exec = require('child_process').exec;
+var rename = require("gulp-rename");
+var del = require('del');
+var sourcemaps = require('gulp-sourcemaps');
+var zip = require('gulp-zip');
+var ts = require("gulp-typescript");
+var nodemon = require("gulp-nodemon");
+var uglify = require('gulp-uglify');
+var gulpIf = require('gulp-if');
+const { ESLint } = require('eslint');
+const fs = require('fs');
+
+
+var paths = {
+    src: 'src/**/*',
+    srcTS: 'src/**/*.ts',
+    srcPrivate: 'src/private/**/*',
+
+    tmp: 'tmp',
+    tmpJS: 'tmp/**/*.js',
+    tmpPrivate: 'tmp/private',
+
+    dist: 'dist',
+    distJS: 'dist/**/*.js',
+    distPrivate: 'dist/private',
+
+    dbDir: 'mongo/data/db',
+    dbLogs: 'mongo/log'
+};
+var shell = require('gulp-shell');
+
+gulp.task('eslint', async function () {
+    const eslint = new ESLint({
+      overrideConfigFile: './eslint.config.js'
+    });
+  
+    const results = await eslint.lintFiles(['./src/**/*.ts']);
+    const formatter = await eslint.loadFormatter('stylish');
+    const resultText = formatter.format(results);
+  
+    console.log(resultText);
+  
+    const hasErrors = results.some(result => result.errorCount > 0);
+  
+    if (hasErrors) {
+      throw new Error('ESLint errors detected');
+    }
+});
+
+gulp.task('clean', function () {
+    return del([paths.tmp, paths.dist]);
+});
+
+// Function to check if MongoDB is running and kill the process if it is
+function killMongoIfRunning(cb) {
+    exec('pgrep mongod', (err, stdout, stderr) => {
+        if (stdout) {
+            console.log('MongoDB is running. Killing the process...');
+            exec('pkill mongod', (killErr, killStdout, killStderr) => {
+                if (killErr) {
+                    console.error('Error killing MongoDB:', killStderr);
+                } else {
+                    console.log('MongoDB process killed.');
+                }
+                cb();
+            });
+        } else {
+            console.log('MongoDB is not running.');
+            cb();
+        }
+    });
+}
+
+// Gulp task to start MongoDB after killing any existing process
+gulp.task('mongo-start', function(done) {
+    killMongoIfRunning(() => {
+        fs.mkdirSync(paths.dbDir, { recursive: true });
+        fs.mkdirSync(paths.dbLogs, { recursive: true });
+
+        const finish = (() => {
+            let completed = false;
+            return (err) => {
+                if (completed) {
+                    return;
+                }
+
+                completed = true;
+                done(err);
+            };
+        })();
+
+        const stream = gulp.src('.')
+            .pipe(shell('mongod --fork --dbpath ' + paths.dbDir + '/ --logpath ' + paths.dbLogs + '/mongo.log --port 3001 --replSet rs0 --bind_ip 127.0.0.1'))
+            .pipe(shell(['mongosh --port 3001 < mongodbensurers.js']));
+
+        stream.on('error', finish);
+        stream.on('end', () => finish());
+        stream.on('finish', () => finish());
+    });
+});
+  
+gulp.task("mongo-stop", function() {
+    return gulp.src('.')
+        .pipe(shell(['killall mongod']));
+});
+
+gulp.task("config", gulp.series("clean", function() {
+    return gulp.src('./settings.development.json')
+        .pipe(rename('settings.json'))
+        .pipe(gulp.dest(paths.tmp));
+}));
+
+gulp.task("email-templates", function() {
+    return gulp.src(paths.srcPrivate)
+        .pipe(gulp.dest(paths.tmpPrivate));
+});
+
+function waitForStreams(streams) {
+	return Promise.all(streams.map((stream) => {
+		return new Promise((resolve, reject) => {
+			stream.on('finish', resolve);
+			stream.on('end', resolve);
+			stream.on('error', reject);
+		});
+	}));
+}
+
+function buildTypeScript(destination) {
+	var tsProject = ts.createProject("tsconfig.json");
+	var tsResult = gulp.src('src/**/*.ts')
+		.pipe(sourcemaps.init())
+		.pipe(tsProject());
+
+	var jsStream = tsResult.js
+		.pipe(sourcemaps.mapSources((sourcePath) => {
+			return sourcePath;
+		}))
+		.pipe(sourcemaps.write("./"))
+		.pipe(gulp.dest(destination));
+
+	var dtsStream = tsResult.dts.pipe(gulp.dest(destination));
+
+	return waitForStreams([jsStream, dtsStream]);
+}
+
+gulp.task("compile", function () {
+	return buildTypeScript(paths.tmp);
+});
+
+gulp.task('watch', function (done) {
+    gulp.watch([paths.src, './node_modules'], gulp.series('compile'));
+
+    done();
+});
+
+gulp.task("default", gulp.parallel(gulp.series("config", "email-templates", 'compile', (done) => {
+    nodemon({
+        script: "tmp/client-server-app.js",
+        watch: "tmp",
+        // exec: 'node --inspect-brk --max-old-space-size=1800 --trace-warnings',
+        exec: 'node --inspect --max-old-space-size=1800 --trace-warnings',
+        delay: 500
+    });
+
+    done();
+}), 'watch'));
+
+gulp.task("config:dist", gulp.series("clean", function() {
+	const configPath = fs.existsSync('./settings.production.json') ? './settings.production.json' : './settings.development.json';
+    return gulp.src(configPath, {allowEmpty: true})
+    .pipe(rename('settings.json'))
+    .pipe(gulp.dest(paths.dist));
+}));
+
+gulp.task("email-templates:dist", function() {
+    return gulp.src(paths.srcPrivate)
+        .pipe(gulp.dest(paths.distPrivate));
+});
+
+gulp.task("compile:dist", function () {
+	return buildTypeScript(paths.dist);
+});
+
+gulp.task("packages:dist", function () {
+    return gulp.src("./package.json")
+        .pipe(gulp.dest(paths.dist));
+});
+
+gulp.task("copy-methods-publications", function() {
+    return gulp.src(['methods.ts', 'publications.ts'])
+        .pipe(gulp.dest(paths.dist));
+});
+
+gulp.task("watch:dist", gulp.series("config:dist", "email-templates:dist", "compile:dist", "packages:dist", "copy-methods-publications", function(done) {
+	gulp.watch(paths.srcTS, gulp.series("compile:dist"));
+	gulp.watch(paths.srcPrivate, gulp.series("email-templates:dist"));
+	gulp.watch(['methods.ts', 'publications.ts'], gulp.series("copy-methods-publications"));
+	done();
+}));
+
+gulp.task("generate-methods-publications", function(done) {
+    exec('python3 methodAndPublicationListGenerator.py', function (err, stdout, stderr) {
+        if (err) {
+            console.error(`exec error: ${err}`);
+            return done(err);
+        }
+        console.log(`stdout: ${stdout}`);
+        console.error(`stderr: ${stderr}`);
+        done();
+    });
+});
+
+gulp.task("build-prod", gulp.series("eslint", "config", "email-templates:dist", "compile:dist", "packages:dist", "generate-methods-publications", "copy-methods-publications", function () {
+    return gulp.src(paths.dist + "/**/*", {dot : true});
+}));

package/methodAndPublicationListGenerator.py

@@ -0,0 +1,375 @@
+import os
+import re
+
+def parse_directory(directory, extension=".ts"):
+    files = []
+    for root, _, file_list in os.walk(directory):
+        for file in file_list:
+            if file.endswith(extension):
+                files.append(os.path.join(root, file))
+    return files
+
+def split_params(params):
+    parts = []
+    buf = ''
+    depth_paren = 0
+    depth_brace = 0
+    depth_bracket = 0
+    depth_angle = 0
+    in_single = False
+    in_double = False
+    in_template = False
+    escape = False
+
+    for ch in params:
+        if escape:
+            buf += ch
+            escape = False
+            continue
+
+        if ch == '\\' and (in_single or in_double or in_template):
+            buf += ch
+            escape = True
+            continue
+
+        if ch == "'" and not in_double and not in_template:
+            in_single = not in_single
+            buf += ch
+            continue
+
+        if ch == '"' and not in_single and not in_template:
+            in_double = not in_double
+            buf += ch
+            continue
+
+        if ch == '`' and not in_single and not in_double:
+            in_template = not in_template
+            buf += ch
+            continue
+
+        if in_single or in_double or in_template:
+            buf += ch
+            continue
+
+        if ch == '(':
+            depth_paren += 1
+        elif ch == ')':
+            depth_paren = max(0, depth_paren - 1)
+        elif ch == '{':
+            depth_brace += 1
+        elif ch == '}':
+            depth_brace = max(0, depth_brace - 1)
+        elif ch == '[':
+            depth_bracket += 1
+        elif ch == ']':
+            depth_bracket = max(0, depth_bracket - 1)
+        elif ch == '<':
+            depth_angle += 1
+        elif ch == '>':
+            depth_angle = max(0, depth_angle - 1)
+
+        if ch == ',' and depth_paren == 0 and depth_brace == 0 and depth_bracket == 0 and depth_angle == 0:
+            if buf.strip():
+                parts.append(buf.strip())
+            buf = ''
+            continue
+
+        buf += ch
+
+    if buf.strip():
+        parts.append(buf.strip())
+
+    return parts
+
+def build_param_lists(params):
+    param_list = []
+    call_params = []
+
+    for param in split_params(params):
+        param = param.strip()
+        if not param:
+            continue
+
+        param_parts = param.split(':', 1)
+        param_name = param_parts[0].strip().replace('?', '').split('=')[0].strip()
+        param_type = param_parts[1].strip() if len(param_parts) > 1 else ''
+
+        param_list.append(param)
+        call_params.append(param_name)
+
+    return param_list, call_params
+
+def get_param_name(param):
+    return param.split(':', 1)[0].strip().replace('?', '').split('=')[0].strip()
+
+def is_optional_param(param):
+    name_part = param.split(':', 1)[0].strip()
+    return '?' in name_part or '=' in name_part
+
+def trim_user_specific_publication_params(param_list, call_params, is_user_specific, publication_name='unknown'):
+    if not is_user_specific:
+        return param_list, call_params
+
+    if not param_list or not call_params:
+        return param_list, call_params
+
+    first_param_name = get_param_name(param_list[0])
+    if first_param_name not in ('id_user', 'id_current_user'):
+        raise ValueError(f"user_specific publication {publication_name} must declare injected user id as the first parameter")
+
+    if publication_name.endswith('ForUser') and len(param_list) == 1 and first_param_name == 'id_user' and is_optional_param(param_list[0]):
+        raise ValueError(
+            f"user_specific publication {publication_name} has ambiguous optional id_user parameter; "
+            "declare function(id_current_user: string, id_user?: string) when the client may pass a target user, "
+            "or function(id_user: string) when only the logged-in user is injected"
+        )
+
+    return param_list[1:], call_params[1:]
+
+def extract_methods_from_lines(lines):
+    methods = {}
+    inside_methods_block = False
+    inside_string = False
+    method_depth = 0
+    tmp_method = None
+    types_used = set()
+
+    for line in lines:
+        line = line.strip()
+
+        if not inside_string and re.search(r'(\.methods\(\s*\{)', line):
+            inside_methods_block = True
+            method_depth = 1
+            continue
+
+        if not inside_methods_block:
+            continue
+
+        inside_string = not inside_string if re.search(r'(?<!\\)(\'|")', line) else inside_string
+
+        method_depth += line.count('{') - line.count('}')
+
+        if method_depth == 2 and re.match(r'^[a-zA-Z0-9_]+:\s*\{', line):
+            tmp_method = re.match(r'^([a-zA-Z0-9_]+):\s*\{', line).group(1)
+
+        if tmp_method and method_depth == 3 and (re.search(r'function:\s*function\s*\(', line) or re.search(r'function:\s*async\s*function\s*\(', line)):
+            function_match = re.search(r'function\s*\(([^)]*)\)', line)
+
+            if function_match:
+                params = function_match.group(1).strip()
+                param_list = []
+                call_params = []
+                for param in split_params(params):
+                    param_parts = param.split(':', 1)
+                    param_name = param_parts[0].strip().replace('?', '').split('=')[0].strip()
+                    param_type = param_parts[1].strip() if len(param_parts) > 1 else ''
+
+                    # Handle arrays or other complex types
+                    base_type = re.sub(r'\[\]|\<.*?\>', '', param_type).strip()
+                    if base_type:
+                        types_used.add(base_type)
+                    param_list.append(param.strip())
+                    call_params.append(param_name)
+
+                tmp_parameters = ", ".join(param_list)
+
+                if tmp_parameters:
+                    method_line = f"\t\t{tmp_method}: ({tmp_parameters}, cb?: Function): Promise<any> => {{"
+                    call_line = f"\t\t\treturn resolveioServer.call('{tmp_method}', {', '.join(call_params)}, cb);"
+                else:
+                    method_line = f"\t\t{tmp_method}: (cb?: Function): Promise<any> => {{"
+                    call_line = f"\t\t\treturn resolveioServer.call('{tmp_method}', cb);"
+                
+                methods[tmp_method] = [method_line, call_line, "\t\t},"]
+            tmp_method = None
+
+        if method_depth == 0 and '});' in line:
+            inside_methods_block = False
+
+    return methods, types_used
+
+def extract_publications_from_lines(lines):
+    publications = {}
+    inside_publications_block = False
+    inside_string = False
+    publication_depth = 0
+    tmp_publication = None
+    types_used = set()
+    tmp_param_list = None
+    tmp_call_params = None
+    tmp_user_specific = False
+
+    for line in lines:
+        line = line.strip()
+
+        if not inside_string and re.search(r'(\.publications\(\s*\{)', line):
+            inside_publications_block = True
+            publication_depth = 1
+            continue
+
+        if not inside_publications_block:
+            continue
+
+        inside_string = not inside_string if re.search(r'(?<!\\)(\'|")', line) else inside_string
+
+        publication_depth += line.count('{') - line.count('}')
+
+        if publication_depth == 2 and re.match(r'^[a-zA-Z0-9_]+:\s*\{', line):
+            tmp_publication = re.match(r'^([a-zA-Z0-9_]+):\s*\{', line).group(1)
+            tmp_param_list = None
+            tmp_call_params = None
+            tmp_user_specific = False
+
+        if tmp_publication and publication_depth == 3 and (re.search(r'function:\s*function\s*\(', line) or re.search(r'function:\s*async\s*function\s*\(', line)):
+            function_match = re.search(r'function\s*\(([^)]*)\)', line)
+
+            if function_match:
+                params = function_match.group(1).strip()
+                tmp_param_list, tmp_call_params = build_param_lists(params)
+                for param in tmp_param_list:
+                    param_parts = param.split(':', 1)
+                    param_type = param_parts[1].strip() if len(param_parts) > 1 else ''
+                    base_type = re.sub(r'\[\]|\<.*?\>', '', param_type).strip()
+                    if base_type:
+                        types_used.add(base_type)
+
+        if tmp_publication and publication_depth >= 2 and re.search(r'user_specific\s*:\s*true', line):
+            tmp_user_specific = True
+
+        if tmp_publication and publication_depth == 1 and tmp_param_list is not None:
+            param_list, call_params = trim_user_specific_publication_params(
+                tmp_param_list,
+                tmp_call_params,
+                tmp_user_specific,
+                tmp_publication
+            )
+            tmp_parameters = ", ".join(param_list)
+
+            if tmp_parameters:
+                publication_line = f"\t\t{tmp_publication}: ({tmp_parameters}) => {{"
+                call_line = f"\t\t\treturn <Observable<any>> resolveioServer.subscribe('{tmp_publication}', {', '.join(call_params)});"
+            else:
+                publication_line = f"\t\t{tmp_publication}: () => {{"
+                call_line = f"\t\t\treturn <Observable<any>> resolveioServer.subscribe('{tmp_publication}');"
+
+            publications[tmp_publication] = [publication_line, call_line, "\t\t},"]
+            tmp_publication = None
+            tmp_param_list = None
+            tmp_call_params = None
+            tmp_user_specific = False
+
+        if publication_depth == 0 and '});' in line:
+            inside_publications_block = False
+
+    return publications, types_used
+
+def generate_import_statements(types_used, models_directory):
+    import_statements = []
+    available_models = {}
+
+    # Scan the models directory to find available models and types
+    for root, _, files in os.walk(models_directory):
+        for file in files:
+            if file.endswith(".ts"):
+                file_path = os.path.join(root, file)
+                with open(file_path, 'r') as model_file:
+                    model_content = model_file.read()
+
+                    # Look for both interface and type exports
+                    export_matches = re.findall(r'export\s+(?:interface|type)\s+([a-zA-Z0-9_]+)', model_content)
+                    for match in export_matches:
+                        available_models[match] = os.path.relpath(file_path, start=os.path.dirname(models_directory)).replace("\\", "/").replace(".ts", "")
+
+    # Generate import statements for types used
+    for type_name in types_used:
+        if type_name in available_models:
+            import_path = available_models[type_name]
+            import_statements.append(f"import {{ {type_name} }} from './{import_path}';")
+
+    return sorted(import_statements)
+
+def generate_methods_file(files, models_directory, output_file):
+    method_blocks = {}  # Dictionary to hold method blocks
+    all_types_used = set()  # Set to track types used
+
+    # Iterate over each file and extract methods
+    for file in files:
+        with open(file, 'r') as f:
+            lines = f.readlines()
+            extracted_methods, types_used = extract_methods_from_lines(lines)
+
+            # Collect all method blocks from this file into method_blocks
+            method_blocks.update(extracted_methods)
+
+            # Collect types used
+            all_types_used.update(types_used)
+
+    # Sort methods globally by their method names
+    sorted_method_names = sorted(method_blocks.keys())
+
+    # Generate import statements
+    import_statements = generate_import_statements(all_types_used, models_directory)
+
+    # Write to the output file
+    with open(output_file, 'w') as f:
+        for import_statement in import_statements:
+            f.write(f"{import_statement}\n")
+        f.write("\nexport function SERVER_METHODS(resolveioServer) {\n")
+        f.write("\treturn {\n")
+
+        # Append sorted methods to the file
+        for method_name in sorted_method_names:
+            for line in method_blocks[method_name]:
+                f.write(f"{line}\n")
+
+        f.write("\t};\n")
+        f.write("}\n")
+
+def generate_publications_file(files, models_directory, output_file):
+    publication_blocks = {}  # Dictionary to hold publication blocks
+    all_types_used = set()  # Set to track types used
+
+    # Iterate over each file and extract publications
+    for file in files:
+        with open(file, 'r') as f:
+            lines = f.readlines()
+            extracted_publications, types_used = extract_publications_from_lines(lines)
+
+            # Collect all method blocks from this file into method_blocks
+            publication_blocks.update(extracted_publications)
+
+            # Collect types used
+            all_types_used.update(types_used)
+
+    # Sort publications globally by their publication names
+    sorted_publication_names = sorted(publication_blocks.keys())
+
+    # Generate import statements
+    import_statements = generate_import_statements(all_types_used, models_directory)
+
+    # Write to the output file
+    with open(output_file, 'w') as f:
+        f.write("import { Observable } from 'rxjs';\n")
+        for import_statement in import_statements:
+            f.write(f"{import_statement}\n")
+        f.write("\nexport function SERVER_PUBLICATIONS(resolveioServer) {\n")
+        f.write("\treturn {\n")
+
+        # Append sorted publications to the file
+        for publication_name in sorted_publication_names:
+            for line in publication_blocks[publication_name]:
+                f.write(f"{line}\n")
+
+        f.write("\t};\n")
+        f.write("}\n")
+
+if __name__ == "__main__":
+    method_dir = './src/methods'
+    pub_dir = './src/publications'
+    models_dir = './src/models'
+    
+    method_files = parse_directory(method_dir)
+    pub_files = parse_directory(pub_dir)
+    
+    generate_methods_file(method_files, models_dir, 'methods.ts')
+    generate_publications_file(pub_files, models_dir, 'publications.ts')

package/mongodbensurers.js

@@ -0,0 +1,2 @@
+rs.initiate();
+exit;

package/mongostop.js

@@ -0,0 +1,3 @@
+db.adminCommand( { replSetStepDown: 120, secondaryCatchUpPeriodSecs: 15, force: true } );
+db.shutdownServer();
+exit;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@resolveio/server-lib",
-  "version": "22.3.53",
+  "version": "22.3.55",
   "description": "",
   "scripts": {
     "package": "./build_package.sh",