@cadenza.io/service 1.17.1 → 1.17.3

package/dist/index.js

@@ -730,7 +730,14 @@ var ServiceRegistry = class _ServiceRegistry {
     ).emits("meta.service_registry.service_inserted").emitsOnFail("meta.service_registry.service_insertion_failed");
     this.insertServiceInstanceTask = CadenzaService.createCadenzaDBInsertTask(
       "serviceInstance",
-      {},
+      {
+        onConflict: {
+          target: ["address", "port", "process_pid"],
+          action: {
+            do: "nothing"
+          }
+        }
+      },
       {
         inputSchema: {
           type: "object",
@@ -1141,34 +1148,37 @@ var RestController = class _RestController {
           ).then(
             CadenzaService.createMetaTask(
               "Configure network",
-              (ctx) => {
+              async (ctx) => {
                 let address = "localhost";
                 let port = ctx.__port;
                 let exposed = false;
-                const createHttpServer = (ctx2) => {
-                  const server = import_node_http.default.createServer(ctx2.__app);
-                  ctx2.__httpServer = server;
-                  server.listen(ctx2.__port, () => {
-                    if (typeof server?.address() === "string") {
-                      address = server.address();
-                    } else if (server?.address()?.address === "::") {
-                      if (process.env.NODE_ENV === "development") {
-                        address = "localhost";
-                      } else if (process.env.IS_DOCKER === "true") {
-                        address = process.env.CADENZA_SERVER_URL || "localhost";
+                const createHttpServer = async (ctx2) => {
+                  await new Promise((resolve, reject) => {
+                    const server = import_node_http.default.createServer(ctx2.__app);
+                    ctx2.__httpServer = server;
+                    server.listen(ctx2.__port, () => {
+                      if (typeof server?.address() === "string") {
+                        address = server.address();
+                      } else if (server?.address()?.address === "::") {
+                        if (process.env.NODE_ENV === "development") {
+                          address = "localhost";
+                        } else if (process.env.IS_DOCKER === "true") {
+                          address = process.env.CADENZA_SERVER_URL || "localhost";
+                        }
+                      } else {
+                        address = server?.address()?.address || "";
                       }
-                    } else {
-                      address = server?.address()?.address || "";
-                    }
-                    console.log(`Server is running on ${address}:${port}`);
+                      console.log(`Server is running on ${address}:${port}`);
+                      resolve(address);
+                    });
+                    CadenzaService.createMetaTask(
+                      "Shutdown HTTP Server",
+                      () => server.close(),
+                      "Shuts down the HTTP server"
+                    ).doOn("meta.server_shutdown_requested").emits("meta.rest.shutdown:http");
                   });
-                  CadenzaService.createMetaTask(
-                    "Shutdown HTTP Server",
-                    () => server.close(),
-                    "Shuts down the HTTP server"
-                  ).doOn("meta.server_shutdown_requested").emits("meta.rest.shutdown:http");
                 };
-                const createHttpsServer = (ctx2) => {
+                const createHttpsServer = async (ctx2) => {
                   if (!process.env.SSL_KEY_PATH || !process.env.SSL_CERT_PATH) {
                     throw new Error(
                       "SSL_KEY_PATH and SSL_CERT_PATH must be set"
@@ -1178,38 +1188,46 @@ var RestController = class _RestController {
                     key: import_node_fs.default.readFileSync(process.env.SSL_KEY_PATH),
                     cert: import_node_fs.default.readFileSync(process.env.SSL_CERT_PATH)
                   };
-                  const httpsServer = import_node_https.default.createServer(options, ctx2.__app);
-                  ctx2.__httpsServer = httpsServer;
-                  ctx2.__port = 443;
-                  port = 443;
-                  httpsServer.listen(443, () => {
-                    if (typeof httpsServer?.address() === "string") {
-                      address = httpsServer.address();
-                    } else if (httpsServer?.address()?.address === "::") {
-                      if (process.env.IS_DOCKER === "true") {
-                        address = process.env.CADENZA_SERVER_URL || "localhost";
+                  await new Promise((resolve, reject) => {
+                    const httpsServer = import_node_https.default.createServer(
+                      options,
+                      ctx2.__app
+                    );
+                    ctx2.__httpsServer = httpsServer;
+                    ctx2.__port = 443;
+                    port = 443;
+                    httpsServer.listen(443, () => {
+                      if (typeof httpsServer?.address() === "string") {
+                        address = httpsServer.address();
+                      } else if (httpsServer?.address()?.address === "::") {
+                        if (process.env.IS_DOCKER === "true") {
+                          address = process.env.CADENZA_SERVER_URL || "localhost";
+                        }
+                      } else {
+                        address = httpsServer?.address()?.address || "";
                       }
-                    } else {
-                      address = httpsServer?.address()?.address || "";
-                    }
-                    exposed = true;
-                    console.log(`HTTPS Server is running on ${address}:443`);
+                      exposed = true;
+                      console.log(
+                        `HTTPS Server is running on ${address}:443`
+                      );
+                      resolve(address);
+                    });
+                    CadenzaService.createMetaTask(
+                      "Shutdown HTTPS Server",
+                      () => httpsServer.close(),
+                      "Shuts down the HTTPS server"
+                    ).doOn("meta.server_shutdown_requested").emits("meta.rest.shutdown:https");
                   });
-                  CadenzaService.createMetaTask(
-                    "Shutdown HTTPS Server",
-                    () => httpsServer.close(),
-                    "Shuts down the HTTPS server"
-                  ).doOn("meta.server_shutdown_requested").emits("meta.rest.shutdown:https");
                 };
                 if (ctx.__networkMode === "internal" || ctx.__networkMode === "dev") {
-                  createHttpServer(ctx);
+                  await createHttpServer(ctx);
                 } else if (ctx.__networkMode === "exposed") {
-                  createHttpServer(ctx);
-                  createHttpsServer(ctx);
+                  await createHttpServer(ctx);
+                  await createHttpsServer(ctx);
                 } else if (ctx.__networkMode === "exposed-high-sec") {
-                  createHttpsServer(ctx);
+                  await createHttpsServer(ctx);
                 } else if (ctx.__networkMode === "auto") {
-                  createHttpServer(ctx);
+                  await createHttpServer(ctx);
                 }
                 ctx.data = {
                   uuid: ctx.__serviceInstanceId,
@@ -2331,9 +2349,10 @@ var DatabaseController = class _DatabaseController {
                       return def;
                     }).join(", ");
                     if (schema.meta?.dropExisting) {
-                      await this.dbClient.query(
-                        `DROP TABLE IF EXISTS ${tableName} CASCADE;`
+                      const result = await this.dbClient.query(
+                        `DELETE FROM ${tableName};`
                       );
+                      console.log("DROP TABLE", tableName, result);
                     }
                     const sql = `CREATE TABLE IF NOT EXISTS ${tableName} (${fieldDefs})`;
                     ddl.push(sql);