@xmobitea/gn-server 2.6.3 → 2.6.5

package/dist/GN-startup/cloudScript/templateCloudScript.ts

@@ -7,8 +7,7 @@ import {
 	Action4,
 	ConverterService,
 	OwnerType,
-	GNErrorCode,
-	GNParameterCode,
+	ErrorCode,
 	ParameterCode,
 	Commands,
 	EventCode,
@@ -60,14 +59,14 @@ import {
 	GroupStatus,
 	GNDebug,
 	ItemType,
-    StoreItemType,
+	StoreItemType,
 	LogType,
 	GNSupport,
 	PostType,
-    GetAuthInfoResponse,
-    PushPlatformType,
-    StoreReceiveType,
-    GNUtils,
+	GetAuthInfoResponse,
+	PushPlatformType,
+	StoreReceiveType,
+	GNUtils,
 } from "@xmobitea/gn-typescript-client";
 
 import * as mongodb from "mongodb";
@@ -82,9 +81,8 @@ enum CloudScriptEventType {
 interface CloudScriptEvent {
 	eventType: CloudScriptEventType;
 	operationEvent: {
-		eventCode: number;
+		eventCode: string;
 		parameters: {} | null;
-		encrypted: boolean;
 	};
 	receiver: string[] | string | null;
 }
@@ -100,56 +98,56 @@ class CloudScriptAdmin {
 	public readonly multiplayer = GNNetwork.multiplayer.admin;
 	public readonly cloudScript = GNNetwork.cloudScript.admin;
 	public readonly dashboard = {
-        getAdminAccountList: GNNetwork.dashboard.getAdminAccountList,
-        getAdminAccountListAsync: GNNetwork.dashboard.getAdminAccountListAsync,
-        getGameInformation: GNNetwork.dashboard.getGameInformation,
-        getGameInformationAsync: GNNetwork.dashboard.getGameInformationAsync,
-        getGameList: GNNetwork.dashboard.getGameList,
-        getGameListAsync: GNNetwork.dashboard.getGameListAsync,
-        getMasterGameSettings: GNNetwork.dashboard.getMasterGameSettings,
-        getMasterGameSettingsAsync: GNNetwork.dashboard.getMasterGameSettingsAsync,
-        getSecretInfoInformation: GNNetwork.dashboard.getSecretInfoInformation,
-        getSecretInfoInformationAsync: GNNetwork.dashboard.getSecretInfoInformationAsync,
-        getSecretInfoList: GNNetwork.dashboard.getSecretInfoList,
-        getSecretInfoListAsync: GNNetwork.dashboard.getSecretInfoListAsync,
-        getServerLog: GNNetwork.dashboard.getServerLog,
-        getServerLogAsync: GNNetwork.dashboard.getServerLogAsync,
-        setGameInformation: GNNetwork.dashboard.setGameInformation,
-        setGameInformationAsync: GNNetwork.dashboard.setGameInformationAsync,
-        getUsernameAdminAccount: GNNetwork.dashboard.getUsernameAdminAccount,
-        getUsernameAdminAccountAsync: GNNetwork.dashboard.getUsernameAdminAccountAsync,
-        getAnalytics: GNNetwork.dashboard.getAnalytics,
-        getAnalyticsAsync: GNNetwork.dashboard.getAnalyticsAsync,
-        resetStatisticsLeaderboard: GNNetwork.dashboard.resetStatisticsLeaderboard,
-        resetStatisticsLeaderboardAsync: GNNetwork.dashboard.resetStatisticsLeaderboardAsync,
-        getBackupStatisticsLeaderboardVersion: GNNetwork.dashboard.getBackupStatisticsLeaderboardVersion,
-        getBackupStatisticsLeaderboardVersionAsync: GNNetwork.dashboard.getBackupStatisticsLeaderboardVersionAsync,
-        getServerGameData: GNNetwork.dashboard.getServerGameData,
-        getServerGameDataAsync: GNNetwork.dashboard.getServerGameDataAsync,
-        deleteInDatabase: GNNetwork.dashboard.deleteInDatabase,
-        deleteInDatabaseAsync: GNNetwork.dashboard.deleteInDatabaseAsync,
-    };
+		getAdminAccountList: GNNetwork.dashboard.getAdminAccountList,
+		getAdminAccountListAsync: GNNetwork.dashboard.getAdminAccountListAsync,
+		getGameInformation: GNNetwork.dashboard.getGameInformation,
+		getGameInformationAsync: GNNetwork.dashboard.getGameInformationAsync,
+		getGameList: GNNetwork.dashboard.getGameList,
+		getGameListAsync: GNNetwork.dashboard.getGameListAsync,
+		getMasterGameSettings: GNNetwork.dashboard.getMasterGameSettings,
+		getMasterGameSettingsAsync: GNNetwork.dashboard.getMasterGameSettingsAsync,
+		getSecretInfoInformation: GNNetwork.dashboard.getSecretInfoInformation,
+		getSecretInfoInformationAsync: GNNetwork.dashboard.getSecretInfoInformationAsync,
+		getSecretInfoList: GNNetwork.dashboard.getSecretInfoList,
+		getSecretInfoListAsync: GNNetwork.dashboard.getSecretInfoListAsync,
+		getServerLog: GNNetwork.dashboard.getServerLog,
+		getServerLogAsync: GNNetwork.dashboard.getServerLogAsync,
+		setGameInformation: GNNetwork.dashboard.setGameInformation,
+		setGameInformationAsync: GNNetwork.dashboard.setGameInformationAsync,
+		getUsernameAdminAccount: GNNetwork.dashboard.getUsernameAdminAccount,
+		getUsernameAdminAccountAsync: GNNetwork.dashboard.getUsernameAdminAccountAsync,
+		getAnalytics: GNNetwork.dashboard.getAnalytics,
+		getAnalyticsAsync: GNNetwork.dashboard.getAnalyticsAsync,
+		resetStatisticsLeaderboard: GNNetwork.dashboard.resetStatisticsLeaderboard,
+		resetStatisticsLeaderboardAsync: GNNetwork.dashboard.resetStatisticsLeaderboardAsync,
+		getBackupStatisticsLeaderboardVersion: GNNetwork.dashboard.getBackupStatisticsLeaderboardVersion,
+		getBackupStatisticsLeaderboardVersionAsync: GNNetwork.dashboard.getBackupStatisticsLeaderboardVersionAsync,
+		getServerGameData: GNNetwork.dashboard.getServerGameData,
+		getServerGameDataAsync: GNNetwork.dashboard.getServerGameDataAsync,
+		deleteInDatabase: GNNetwork.dashboard.deleteInDatabase,
+		deleteInDatabaseAsync: GNNetwork.dashboard.deleteInDatabaseAsync,
+	};
 	public send(
 		requestType: RequestType,
-		requestRole: RequestRole,
+		role: RequestRole,
 		request: OperationRequest,
 		onResponse: Action1<OperationResponse>,
 		overrideAuthToken: string,
 		overrideSecretKey: string,
 		customTags: GNHashtable
 	): void {
-		GNNetwork.sendViaHttp(requestType, requestRole, request, onResponse, overrideAuthToken, overrideSecretKey, customTags);
+		GNNetwork.sendViaHttp(requestType, role, request, onResponse, overrideAuthToken, overrideSecretKey, customTags);
 	}
 
 	public sendAsync(
 		requestType: RequestType,
-		requestRole: RequestRole,
+		role: RequestRole,
 		request: OperationRequest,
 		overrideAuthToken: string,
 		overrideSecretKey: string,
 		customTags: GNHashtable
 	): Promise<OperationResponse> {
-		return GNNetwork.sendViaHttpAsync(requestType, requestRole, request, overrideAuthToken, overrideSecretKey, customTags);
+		return GNNetwork.sendViaHttpAsync(requestType, role, request, overrideAuthToken, overrideSecretKey, customTags);
 	}
 }
 
@@ -162,45 +160,87 @@ class CloudScriptDatabase {
 	private client: mongodb.MongoClient;
 	private db: mongodb.Db;
 
-	init(url: string, dbName: string, options?: mongodb.MongoClientOptions): void {
+	private logClient: mongodb.MongoClient;
+	private logDb: mongodb.Db;
+
+	init(url: string, dbName: string, logUrl: string, logDbName: string, options?: mongodb.MongoClientOptions): void {
 		this.client = new mongodb.MongoClient(url, options);
 
 		this.db = this.client.db(dbName);
 
-		this.client.connect();
+		if (!logUrl || logUrl == "" || logUrl == url) {
+			this.logClient = this.client;
+			this.logDb = this.db;
+		}
+		else {
+			this.logClient = new mongodb.MongoClient(logUrl, options);
+			this.logDb = this.logClient.db(logDbName);
+		}
 	}
 
-	public runtimeCollection(collectionName: string): mongodb.Collection<mongodb.Document> {
-		return this.collection(CloudScriptDatabase.RUNTIME + collectionName);
+	public runtimeCollection<TSchema extends mongodb.Document = mongodb.Document>(collectionName: string): mongodb.Collection<TSchema> {
+		return this.collection<TSchema>(CloudScriptDatabase.RUNTIME + collectionName);
 	}
 
-	public metaCollection(collectionName: string): mongodb.Collection<mongodb.Document> {
-		return this.collection(CloudScriptDatabase.META + collectionName);
+	public metaCollection<TSchema extends mongodb.Document = mongodb.Document>(collectionName: string): mongodb.Collection<TSchema> {
+		return this.collection<TSchema>(CloudScriptDatabase.META + collectionName);
 	}
 
-	public systemCollection(collectionName: string): mongodb.Collection<mongodb.Document> {
-		return this.collection(CloudScriptDatabase.SYSTEM + collectionName);
+	public systemCollection<TSchema extends mongodb.Document = mongodb.Document>(collectionName: string): mongodb.Collection<TSchema> {
+		return this.collection<TSchema>(CloudScriptDatabase.SYSTEM + collectionName);
 	}
 
-	public runtimeGameCollection(collectionName: string, gameId: string): mongodb.Collection<mongodb.Document> {
-		return this.collection(CloudScriptDatabase.RUNTIME + gameId + CloudScriptDatabase.DOT + collectionName);
+	public runtimeGameCollection<TSchema extends mongodb.Document = mongodb.Document>(collectionName: string, gameId: string): mongodb.Collection<TSchema> {
+		return this.collection<TSchema>(CloudScriptDatabase.RUNTIME + gameId + CloudScriptDatabase.DOT + collectionName);
 	}
 
-	public metaGameCollection(collectionName: string, gameId: string): mongodb.Collection<mongodb.Document> {
-		return this.collection(CloudScriptDatabase.META + gameId + CloudScriptDatabase.DOT + collectionName);
+	public metaGameCollection<TSchema extends mongodb.Document = mongodb.Document>(collectionName: string, gameId: string): mongodb.Collection<TSchema> {
+		return this.collection<TSchema>(CloudScriptDatabase.META + gameId + CloudScriptDatabase.DOT + collectionName);
 	}
 
-	public systemGameCollection(collectionName: string, gameId: string): mongodb.Collection<mongodb.Document> {
-		return this.collection(CloudScriptDatabase.SYSTEM + gameId + CloudScriptDatabase.DOT + collectionName);
+	public systemGameCollection<TSchema extends mongodb.Document = mongodb.Document>(collectionName: string, gameId: string): mongodb.Collection<TSchema> {
+		return this.collection<TSchema>(CloudScriptDatabase.SYSTEM + gameId + CloudScriptDatabase.DOT + collectionName);
 	}
 
-	public collection(fullCollectionName: string): mongodb.Collection<mongodb.Document> {
-		return this.db.collection(fullCollectionName);
+	public collection<TSchema extends mongodb.Document = mongodb.Document>(fullCollectionName: string): mongodb.Collection<TSchema> {
+		return this.db.collection<TSchema>(fullCollectionName);
 	}
 
 	public createCollection(name: string, options?: mongodb.CreateCollectionOptions): Promise<mongodb.Collection<mongodb.BSON.Document>> {
 		return this.db.createCollection(name, options);
 	}
+
+	public logRuntimeCollection<TSchema extends mongodb.Document = mongodb.Document>(collectionName: string): mongodb.Collection<TSchema> {
+		return this.logCollection<TSchema>(CloudScriptDatabase.RUNTIME + collectionName);
+	}
+
+	public logMetaCollection<TSchema extends mongodb.Document = mongodb.Document>(collectionName: string): mongodb.Collection<TSchema> {
+		return this.logCollection<TSchema>(CloudScriptDatabase.META + collectionName);
+	}
+
+	public logSystemCollection<TSchema extends mongodb.Document = mongodb.Document>(collectionName: string): mongodb.Collection<TSchema> {
+		return this.logCollection<TSchema>(CloudScriptDatabase.SYSTEM + collectionName);
+	}
+
+	public logRuntimeGameCollection<TSchema extends mongodb.Document = mongodb.Document>(collectionName: string, gameId: string): mongodb.Collection<TSchema> {
+		return this.logCollection<TSchema>(CloudScriptDatabase.RUNTIME + gameId + CloudScriptDatabase.DOT + collectionName);
+	}
+
+	public logMetaGameCollection<TSchema extends mongodb.Document = mongodb.Document>(collectionName: string, gameId: string): mongodb.Collection<TSchema> {
+		return this.logCollection<TSchema>(CloudScriptDatabase.META + gameId + CloudScriptDatabase.DOT + collectionName);
+	}
+
+	public logSystemGameCollection<TSchema extends mongodb.Document = mongodb.Document>(collectionName: string, gameId: string): mongodb.Collection<TSchema> {
+		return this.logCollection<TSchema>(CloudScriptDatabase.SYSTEM + gameId + CloudScriptDatabase.DOT + collectionName);
+	}
+
+	public logCollection<TSchema extends mongodb.Document = mongodb.Document>(fullCollectionName: string): mongodb.Collection<TSchema> {
+		return this.logDb.collection<TSchema>(fullCollectionName);
+	}
+
+	public logCreateCollection<TSchema extends mongodb.Document = mongodb.Document>(collectionName: string, options?: mongodb.CreateCollectionOptions) {
+		return this.logDb.createCollection<TSchema>(collectionName, options)
+	}
 }
 
 class CloudScriptHttp {
@@ -240,7 +280,6 @@ class CloudScriptSocket {
 			receiver: userId,
 			operationEvent: {
 				eventCode: operationEvent.getEventCode(),
-				encrypted: operationEvent.isEncrypted(),
 				parameters: operationEvent.getParameters()?.toData() ?? null,
 			}
 		});
@@ -252,7 +291,6 @@ class CloudScriptSocket {
 			receiver: userIds,
 			operationEvent: {
 				eventCode: operationEvent.getEventCode(),
-				encrypted: operationEvent.isEncrypted(),
 				parameters: operationEvent.getParameters()?.toData() ?? null,
 			}
 		});
@@ -264,7 +302,6 @@ class CloudScriptSocket {
 			receiver: null,
 			operationEvent: {
 				eventCode: operationEvent.getEventCode(),
-				encrypted: operationEvent.isEncrypted(),
 				parameters: operationEvent.getParameters()?.toData() ?? null,
 			}
 		});
@@ -272,140 +309,133 @@ class CloudScriptSocket {
 
 	private async sendEvent(event: CloudScriptEvent) {
 		if (process?.send)
-            process.send(event);
+			process.send(event);
 	}
 }
 
 class CloudScriptMail {
 	public async send(email: string, subject: string, contentHtml: string) {
 		if (process?.send)
-            process.send({
-                eventType: 20,
-                receiver: null,
-                operationEvent: {
-                    eventCode: 0,
-                    encrypted: false,
-                    parameters: {
-                        email: email,
-                        subject: subject,
-                        contentHtml: contentHtml,
-                    },
-                },
-            });
+			process.send({
+				eventType: 20,
+				receiver: null,
+				operationEvent: {
+					eventCode: 0,
+					parameters: {
+						email: email,
+						subject: subject,
+						contentHtml: contentHtml,
+					},
+				},
+			});
 	}
 
 	public async sendToMore(emails: string[], subject: string, contentHtml: string) {
-        if (process?.send)
-            process.send({
-                eventType: 21,
-                receiver: null,
-                operationEvent: {
-                    eventCode: 0,
-                    encrypted: false,
-                    parameters: {
-                        emails: emails,
-                        subject: subject,
-                        contentHtml: contentHtml,
-                    },
-                },
-            });
+		if (process?.send)
+			process.send({
+				eventType: 21,
+				receiver: null,
+				operationEvent: {
+					eventCode: 0,
+					parameters: {
+						emails: emails,
+						subject: subject,
+						contentHtml: contentHtml,
+					},
+				},
+			});
 	}
 }
 
 class CloudScriptPushNotification {
 	public async send(token: string, title: string, body: string, badge?: number, sound?: string, icon?: string, data?: { [k: string]: any }) {
 		if (process?.send)
-            process.send({
-                eventType: 30,
-                receiver: null,
-                operationEvent: {
-                    eventCode: 0,
-                    encrypted: false,
-                    parameters: {
-                        token: token,
-                        title: title,
-                        body: body,
-                        badge: badge,
-                        sound: sound,
-                        icon: icon,
-                        data: data,
-                    },
-                },
-            });
+			process.send({
+				eventType: 30,
+				receiver: null,
+				operationEvent: {
+					eventCode: 0,
+					parameters: {
+						token: token,
+						title: title,
+						body: body,
+						badge: badge,
+						sound: sound,
+						icon: icon,
+						data: data,
+					},
+				},
+			});
 	}
 
 	public async sendToMore(tokens: string[], title: string, body: string, badge?: number, sound?: string, icon?: string, data?: { [k: string]: any }) {
 		if (process?.send)
-            process.send({
-                eventType: 31,
-                receiver: null,
-                operationEvent: {
-                    eventCode: 0,
-                    encrypted: false,
-                    parameters: {
-                        tokens: tokens,
-                        title: title,
-                        body: body,
-                        badge: badge,
-                        sound: sound,
-                        icon: icon,
-                        data: data,
-                    },
-                },
-            });
+			process.send({
+				eventType: 31,
+				receiver: null,
+				operationEvent: {
+					eventCode: 0,
+					parameters: {
+						tokens: tokens,
+						title: title,
+						body: body,
+						badge: badge,
+						sound: sound,
+						icon: icon,
+						data: data,
+					},
+				},
+			});
 	}
 
 	public async sendToTopic(topic: string, title: string, body: string, badge?: number, sound?: string, icon?: string, data?: { [k: string]: any }) {
 		if (process?.send)
-            process.send({
-                eventType: 32,
-                receiver: null,
-                operationEvent: {
-                    eventCode: 0,
-                    encrypted: false,
-                    parameters: {
-                        topic: topic,
-                        title: title,
-                        body: body,
-                        badge: badge,
-                        sound: sound,
-                        icon: icon,
-                        data: data,
-                    },
-                },
-            });
-	}
-
-    public async subscribeToTopic(tokens: string[], topic: string) {
+			process.send({
+				eventType: 32,
+				receiver: null,
+				operationEvent: {
+					eventCode: 0,
+					parameters: {
+						topic: topic,
+						title: title,
+						body: body,
+						badge: badge,
+						sound: sound,
+						icon: icon,
+						data: data,
+					},
+				},
+			});
+	}
+
+	public async subscribeToTopic(tokens: string[], topic: string) {
 		if (process?.send)
-            process.send({
-                eventType: 33,
-                receiver: null,
-                operationEvent: {
-                    eventCode: 0,
-                    encrypted: false,
-                    parameters: {
-                        tokens: tokens,
-                        topic: topic,
-                    },
-                },
-            });
-	}
-
-    public async unsubscribeFromTopic(tokens: string[], topic: string) {
+			process.send({
+				eventType: 33,
+				receiver: null,
+				operationEvent: {
+					eventCode: 0,
+					parameters: {
+						tokens: tokens,
+						topic: topic,
+					},
+				},
+			});
+	}
+
+	public async unsubscribeFromTopic(tokens: string[], topic: string) {
 		if (process?.send)
-            process.send({
-                eventType: 34,
-                receiver: null,
-                operationEvent: {
-                    eventCode: 0,
-                    encrypted: false,
-                    parameters: {
-                        tokens: tokens,
-                        topic: topic,
-                    },
-                },
-            });
+			process.send({
+				eventType: 34,
+				receiver: null,
+				operationEvent: {
+					eventCode: 0,
+					parameters: {
+						tokens: tokens,
+						topic: topic,
+					},
+				},
+			});
 	}
 }
 
@@ -501,82 +531,82 @@ const ConvertArray = (results: any[]) => {
 }
 
 process?.on("message", async (request: CloudScriptRequest) => {
-    let startTime = performance.now();
-    let startMemoryUsage = process.memoryUsage();
-
-    let logs: string[] = [];
-    let functionRequest: FunctionRequest = {
-        userId: request.userId,
-        name: request.name,
-        parameters: request.parameters,
-        context: {},
-        customTags: request.customTags,
-        log(log: any) {
-            logs.push(JSON.stringify(log));
-        },
-    };
-
-    let handleResponse = await ___handleFunction(functionRequest);
-
-    if (handleResponse.result) {
-        if (handleResponse.result instanceof GNHashtable) {
-            handleResponse.result = (<GNHashtable>handleResponse.result).toData();
-        }
-        else if (handleResponse.result instanceof GNArray) {
-            handleResponse.result = (<GNArray>handleResponse.result).toData();
-        }
-        else {
-            let typeofResult = typeof (handleResponse.result);
-
-            if (typeofResult == "boolean") {
-
-            }
-            else if (typeofResult == "number") {
-
-            }
-            else if (typeofResult == "object") {
-                if (Array.isArray(handleResponse.result)) {
-
-                    handleResponse.result = ConvertArray(handleResponse.result as any[]);
-                    //answer.push(this.deserializeArray(gnArray.getGNArray(i), cls));
-                }
-                else {
-                    handleResponse.result = ConvertObject(handleResponse.result);
-                }
-            }
-            else if (typeofResult == "string") {
-
-            }
-            else {
-                handleResponse.result = null;
-
-                handleResponse.errorMessage = "CloudScript must return void, number, string, boolean, null, json dictionary, json array, GNHashtable or GNArray";
-                handleResponse.status = ExecuteResponseStatus.Exception;
-            }
-        }
-    }
-
-    let endTime = performance.now();
-    let endMemoryUsage = process.memoryUsage();
-
-    let memoryUsedInBytes = endMemoryUsage.heapUsed - startMemoryUsage.heapUsed;
-    if (memoryUsedInBytes <= 0) memoryUsedInBytes = 8192;
-    let executeTimeInMs = endTime - startTime;
-
-    //let cost = (memoryUsedInGb * executeTime) / 1000 * 0.022;
-
-    let response: CloudScriptResponse = {
-        responseId: request.requestId,
-        response: handleResponse,
-        stats: {
-            executeTimeInMs: executeTimeInMs,
-            memoryUsedInBytes: memoryUsedInBytes,
-        },
-        logs: logs,
-    };
-
-    if (process?.send)
-        process.send(response);
+	let startTime = performance.now();
+	let startMemoryUsage = process.memoryUsage();
+
+	let logs: string[] = [];
+	let functionRequest: FunctionRequest = {
+		userId: request.userId,
+		name: request.name,
+		parameters: request.parameters,
+		context: {},
+		customTags: request.customTags,
+		log(log: any) {
+			logs.push(JSON.stringify(log));
+		},
+	};
+
+	let handleResponse = await ___handleFunction(functionRequest);
+
+	if (handleResponse.result) {
+		if (handleResponse.result instanceof GNHashtable) {
+			handleResponse.result = (<GNHashtable>handleResponse.result).toData();
+		}
+		else if (handleResponse.result instanceof GNArray) {
+			handleResponse.result = (<GNArray>handleResponse.result).toData();
+		}
+		else {
+			let typeofResult = typeof (handleResponse.result);
+
+			if (typeofResult == "boolean") {
+
+			}
+			else if (typeofResult == "number") {
+
+			}
+			else if (typeofResult == "object") {
+				if (Array.isArray(handleResponse.result)) {
+
+					handleResponse.result = ConvertArray(handleResponse.result as any[]);
+					//answer.push(this.deserializeArray(gnArray.getGNArray(i), cls));
+				}
+				else {
+					handleResponse.result = ConvertObject(handleResponse.result);
+				}
+			}
+			else if (typeofResult == "string") {
+
+			}
+			else {
+				handleResponse.result = null;
+
+				handleResponse.errorMessage = "CloudScript must return void, number, string, boolean, null, json dictionary, json array, GNHashtable or GNArray";
+				handleResponse.status = ExecuteResponseStatus.Exception;
+			}
+		}
+	}
+
+	let endTime = performance.now();
+	let endMemoryUsage = process.memoryUsage();
+
+	let memoryUsedInBytes = endMemoryUsage.heapUsed - startMemoryUsage.heapUsed;
+	if (memoryUsedInBytes <= 0) memoryUsedInBytes = 8192;
+	let executeTimeInMs = endTime - startTime;
+
+	//let cost = (memoryUsedInGb * executeTime) / 1000 * 0.022;
+
+	let response: CloudScriptResponse = {
+		responseId: request.requestId,
+		response: handleResponse,
+		stats: {
+			executeTimeInMs: executeTimeInMs,
+			memoryUsedInBytes: memoryUsedInBytes,
+		},
+		logs: logs,
+	};
+
+	if (process?.send)
+		process.send(response);
 });
 
 async function ___handleFunction(request: FunctionRequest): Promise<FunctionResponse> {
@@ -627,7 +657,7 @@ const pushNotification = new CloudScriptPushNotification();
 
 {
 	let dbConnection = JSON.parse(process.env.dbConnection ?? "");
-	database.init(dbConnection.url, dbConnection.dbName, dbConnection.options);
+	database.init(dbConnection.url, dbConnection.dbName, dbConnection.logUrl, dbConnection.logDbName, dbConnection.options);
 }
 
 process.env.dbConnection = "";