@resolveio/server-lib 22.2.33 → 22.2.34

package/methodAndPublicationListGenerator.py

@@ -0,0 +1,319 @@
+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 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()
+
+    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)
+
+        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()
+                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:
+                    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
+
+        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.2.33",
+  "version": "22.2.34",
   "description": "",
 	"scripts": {
 		"package": "./build_package.sh",

package/settings.development.json

@@ -0,0 +1,25 @@
+{
+    "CLIENT_NAME": "ResolveIO",
+    "DATABASE": "resolveio",
+    "MONGO_URL": "mongodb://127.0.0.1:3001/resolveio",
+    "OPLOG_URL": "mongodb://127.0.0.1:3001/local",
+    "MAIL_URL": "smtps://AKIAISVPD3SREQHE523Q:Ar3qzozs3JFxu00Uw94FBatPKJydEZeBBvdqmpniVSt6@email-smtp.us-east-1.amazonaws.com:465/",
+    "MAIL_FROM": "dev@resolveio.com",
+    "ROOT_URL": "http://localhost:4200",
+    "SERVER_URL": "http://localhost:8080",
+    "SEC_ROOT_URL": "http://localhost:8081",
+    "CLOUDCONVERT": "YiMz1FUvcqrAOnFGbkcKkBbjQw8LmgNz6tGoCvUCuwgHFmDv2XyiEYrOrDJvF7S6CWbCP_RgjhyeFvVMNOVIwQ",
+    "CLOUDCONVERT_V2": "eyJ0eXAiOiJKV1QiLCJhbGciOiJSUzI1NiJ9.eyJhdWQiOiIxIiwianRpIjoiMzcxYzQ2OTE5NjhhOTMxZTc1NTUxNmJiZWRlNmFkOWNhMDMxNGM4ZTU2NmJiNzVlODgwODE1MzljYTk2ZjQ4ZGRhMzU1Yzg4OGQ3ZmZhMWQiLCJpYXQiOjE2MDIyNTg4MDAsIm5iZiI6MTYwMjI1ODgwMCwiZXhwIjo0NzU3OTMyNDAwLCJzdWIiOiIyNzM3OTU2NSIsInNjb3BlcyI6WyJ1c2VyLnJlYWQiLCJ1c2VyLndyaXRlIiwidGFzay5yZWFkIiwidGFzay53cml0ZSIsIndlYmhvb2sucmVhZCIsIndlYmhvb2sud3JpdGUiLCJwcmVzZXQucmVhZCIsInByZXNldC53cml0ZSJdfQ.eD8Tkxmo0HGHkhaeUtIFezdNUvpd0R6exPej-TB3xafY6QlMJzlb2y48JNe4oCikQfOR_0bvOyVexo5-aSaetjl_7nmkgbxwRrlyo9FJFI9k4ERB1daoIH-lIKpW5j5zqm0kU1Gps2y-az7FS1FcB3MAOAMcEXPATWouaSPTSgn9AG9MNNBnLZqO13V7whqjJsCeIwuWxZ5G4a4Nvmlu0WsqEHZtGbkwKRwtZ4a8-zanVw8SED4O2i9PeV4h8dG6Pt0MfBsfGvwSkfPif8eMAHs4elqVLvWUl_oY3-pe_WlG2RKLP5fpVPeyUaT3bRTuwgsi2T-E54fBEXpFcUBjmulB5ihJQwde7RZcGRcg5t5sz0NDlYYr0tyB69GXXku9ayHCiT5qm0F2yAGZV6_K_SXM9_Sjd5a4Nk9HHpSGRfHGoCrhNZFnb1R-y2zbsD4QG3KQLVbsNm7W410_NQEusrCejwcjDUnd3fNlw77-dwPQ_hALKzV-JBl9dVAE_67ONsvweuJHkMsfFyly7rryUh9JRWREAPGXDWJOlnSrzAKmQyTpLyOY-jMj8q2_1lClSauOQn2eqCL45ccDaz_xXGCdDg9QFYfN6Nc8NjkoTShCBG1oFz4UdpEkGptPOviDGelu4u_Fwv_-srh7l1QzFv_2YRpJkzjNw8-vA46h0RQ",
+    "TWILIO_SID": "AC6338adffd405964cf4d2cf0af59abd2e",
+    "TWILIO_AUTH_TOKEN": "8ae1086fff332e069f0b3582e6dafc72",
+    "TWILIO_PHONE_NUMBER": "+18777937285",
+    "JWT_SECRET": "tr3dkmoXWcWGAUxywETXqkpb",
+    "DEBUG_EMAIL": "dev@resolveio.com",
+    "GOOGLE_API_KEY": "AIzaSyCeB_KqVONHrB8e6F6d8LTqhMDCK0GAxqY",
+    "AI_ASSISTANT_CODEX_PLANNER_ENABLED": true,
+    "AI_ASSISTANT_FAST_MODE_ENABLED": false,
+    "AI_ASSISTANT_ALWAYS_ALLOW_PROBE": true,
+    "AI_ASSISTANT_RUN_BUDGET_MS": 120000,
+    "AI_ASSISTANT_MONGO_MAX_TIME_MS": 12000,
+    "AI_ASSISTANT_CODEX_TIMEOUT_MS": 180000
+}

package/settings.development.redacted.json

@@ -0,0 +1,25 @@
+{
+    "CLIENT_NAME": "ResolveIO",
+    "DATABASE": "resolveio",
+    "MONGO_URL": "mongodb://127.0.0.1:3001/resolveio",
+    "OPLOG_URL": "mongodb://127.0.0.1:3001/local",
+    "MAIL_URL": "<REDACTED>",
+    "MAIL_FROM": "<REDACTED>",
+    "ROOT_URL": "http://localhost:4200",
+    "SERVER_URL": "http://localhost:8080",
+    "SEC_ROOT_URL": "http://localhost:8081",
+    "CLOUDCONVERT": "<REDACTED>",
+    "CLOUDCONVERT_V2": "<REDACTED>",
+    "TWILIO_SID": "<REDACTED>",
+    "TWILIO_AUTH_TOKEN": "<REDACTED>",
+    "TWILIO_PHONE_NUMBER": "<REDACTED>",
+    "JWT_SECRET": "<REDACTED>",
+    "DEBUG_EMAIL": "<REDACTED>",
+    "GOOGLE_API_KEY": "<REDACTED>",
+    "AI_ASSISTANT_CODEX_PLANNER_ENABLED": true,
+    "AI_ASSISTANT_FAST_MODE_ENABLED": false,
+    "AI_ASSISTANT_ALWAYS_ALLOW_PROBE": true,
+    "AI_ASSISTANT_RUN_BUDGET_MS": 120000,
+    "AI_ASSISTANT_MONGO_MAX_TIME_MS": 12000,
+    "AI_ASSISTANT_CODEX_TIMEOUT_MS": 180000
+}

package/src/.env

@@ -0,0 +1,12 @@
+PORT=8081
+NPM_TOKEN=5f4981ed-c21d-4648-81cf-4cbbd1c53abe
+TZ=UTC
+TZ_CLIENT=America/Chicago
+AWS_ACCESS_KEY=AKIAJOTKSHQB4QNL7AXA
+AWS_SECRET_ACCESS_KEY=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
+AWS_REGION=us-west-2
+AWS_SES_REGION=us-east-1
+AWS_S3_BUCKET=dpinventorypo
+PM2_KILL_TIMEOUT=10000
+IS_WORKERS_ENABLED=false
+IS_WORKER_INSTANCE=false