@resolveio/server-lib 22.3.221 → 22.3.222

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;