@resolveio/server-lib 22.3.126 → 22.3.127

package/gulpfile.js

@@ -1,216 +0,0 @@
-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

@@ -1,375 +0,0 @@
-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

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

package/mongostop.js

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