@certik/skynet 0.22.1 → 0.22.3

package/dist/address.d.ts

@@ -1,3 +1,2 @@
 export declare function parseAddress(address: string): string[];
 export declare function composeAddress(protocol: string, addr: string): string;
-//# sourceMappingURL=address.d.ts.map

package/dist/address.js

@@ -1,23 +1,24 @@
-export function parseAddress(address) {
-    // in case of address has multiple colons, we only split the first one
-    const separatorIndex = address.indexOf(":");
-    let protocolPart;
-    let addressPart;
-    if (separatorIndex === -1) {
-        // if there is no colon, we assume it is an ethereum address
-        protocolPart = "eth";
-        addressPart = address;
-    }
-    else {
-        protocolPart = address.slice(0, separatorIndex);
-        addressPart = address.slice(separatorIndex + 1);
-    }
-    if (addressPart.startsWith("0x")) {
-        // We only lowercase the address part if it starts with 0x, otherwise it is a case-sensitive address (such as tron)
-        addressPart = addressPart.toLowerCase();
-    }
-    return [protocolPart, addressPart];
+// src/address.ts
+function parseAddress(address) {
+  const separatorIndex = address.indexOf(":");
+  let protocolPart;
+  let addressPart;
+  if (separatorIndex === -1) {
+    protocolPart = "eth";
+    addressPart = address;
+  } else {
+    protocolPart = address.slice(0, separatorIndex);
+    addressPart = address.slice(separatorIndex + 1);
+  }
+  if (addressPart.startsWith("0x")) {
+    addressPart = addressPart.toLowerCase();
+  }
+  return [protocolPart, addressPart];
 }
-export function composeAddress(protocol, addr) {
-    return `${protocol}:${addr}`;
+function composeAddress(protocol, addr) {
+  return `${protocol}:${addr}`;
 }
+export {
+  parseAddress,
+  composeAddress
+};

package/dist/api.d.ts

@@ -29,4 +29,3 @@ export declare function startApiApp({ binaryName, name, selector, routes, serve,
     }) => Promise<void>;
 }): Promise<void>;
 export {};
-//# sourceMappingURL=api.d.ts.map

package/dist/api.js

@@ -1,81 +1,197 @@
+// src/env.ts
+function ensureAndGet(envName, defaultValue) {
+  return process.env[envName] || defaultValue;
+}
+function getEnvironment() {
+  return ensureAndGet("SKYNET_ENVIRONMENT", "dev");
+}
+function getEnvOrThrow(envName) {
+  if (!process.env[envName]) {
+    throw new Error(`Must set environment variable ${envName}`);
+  }
+  return process.env[envName];
+}
+function isProduction() {
+  return getEnvironment() === "prd";
+}
+function isDev() {
+  return getEnvironment() === "dev";
+}
+// src/log.ts
+function isObject(a) {
+  return !!a && a.constructor === Object;
+}
+function print(o) {
+  if (Array.isArray(o)) {
+    return `[${o.map(print).join(", ")}]`;
+  }
+  if (isObject(o)) {
+    return `{${Object.keys(o).map((k) => `${k}: ${o[k]}`).join(", ")}}`;
+  }
+  return `${o}`;
+}
+function getLine(params) {
+  let line = "";
+  for (let i = 0, l = params.length;i < l; i++) {
+    line += `${print(params[i])} `.replace(/\n/gm, "\t");
+  }
+  return line.trim();
+}
+function timestamp() {
+  return new Date().toISOString();
+}
+var inline = {
+  debug: function(...args) {
+    if (true) {
+      console.log(`${timestamp()} ${getLine(args)}`);
+    }
+  },
+  log: function(...args) {
+    if (true) {
+      console.log(`${timestamp()} ${getLine(args)}`);
+    }
+  },
+  error: function(...args) {
+    if (true) {
+      console.error(`${timestamp()} ${getLine(args)}`);
+    }
+  }
+};
+var logger = {
+  debug: function(...args) {
+    if (true) {
+      console.log(`[${timestamp()}]`, ...args);
+    }
+  },
+  log: function(...args) {
+    if (true) {
+      console.log(`[${timestamp()}]`, ...args);
+    }
+  },
+  error: function(...args) {
+    if (true) {
+      console.error(`[${timestamp()}]`, ...args);
+    }
+  }
+};
+// src/selector.ts
+function getSelectorDesc(selector) {
+  return Object.keys(selector).map((name) => {
+    return `          --${name.padEnd(14)}${selector[name].desc || selector[name].description || ""}`;
+  }).join(`
+`);
+}
+function getSelectorFlags(selector) {
+  return Object.keys(selector).reduce((acc, name) => {
+    const flag = {
+      type: selector[name].type || "string",
+      ...selector[name]
+    };
+    if (!selector[name].optional && selector[name].isRequired !== false) {
+      flag.isRequired = true;
+    }
+    return { ...acc, [name]: flag };
+  }, {});
+}
+function toSelectorString(selectorFlags, delim = ",") {
+  return Object.keys(selectorFlags).sort().map((flag) => {
+    return `${flag}=${selectorFlags[flag]}`;
+  }).join(delim);
+}
+function normalizeSelectorValue(v) {
+  return v.replace(/[^A-Za-z0-9]+/g, "-");
+}
+function getJobName(name, selectorFlags, mode) {
+  const selectorNamePart = Object.keys(selectorFlags).sort().map((name2) => selectorFlags[name2]).join("-");
+  let jobName = name;
+  if (mode) {
+    jobName += `-${mode}`;
+  }
+  if (selectorNamePart.length > 0) {
+    jobName += `-${normalizeSelectorValue(selectorNamePart)}`;
+  }
+  return jobName;
+}
+// src/api.ts
 import osModule from "os";
 import express from "express";
 import meow from "meow";
-import { getSelectorDesc, getSelectorFlags } from "./selector";
-import { isProduction } from "./env";
-import { inline } from "./log";
 async function logStartMiddleware(_, res, next) {
-    const start = new Date();
-    res.set("x-requested-at", start.toISOString());
-    next();
+  const start = new Date;
+  res.set("x-requested-at", start.toISOString());
+  next();
 }
 async function contextMiddleware(_, res, next) {
-    res.set("x-instance-id", osModule.hostname());
-    next();
+  res.set("x-instance-id", osModule.hostname());
+  next();
 }
 async function logEndMiddleware(req, res, next) {
-    const requestedAt = res.get("x-requested-at");
-    if (!requestedAt) {
-        inline.log("missing x-requested-at header");
-        next();
-        return;
-    }
-    const start = new Date(requestedAt).getTime();
-    const end = new Date().getTime();
-    const logInfo = {
-        start,
-        end,
-        elapsed: `${end - start}ms`,
-        endpoint: req.path,
-        host: req.hostname,
-        status: res.statusCode,
-    };
-    if (res.statusMessage) {
-        logInfo.errorMessage = res.statusMessage;
-    }
-    inline.log(JSON.stringify(logInfo));
+  const requestedAt = res.get("x-requested-at");
+  if (!requestedAt) {
+    inline.log("missing x-requested-at header");
     next();
+    return;
+  }
+  const start = new Date(requestedAt).getTime();
+  const end = new Date().getTime();
+  const logInfo = {
+    start,
+    end,
+    elapsed: `${end - start}ms`,
+    endpoint: req.path,
+    host: req.hostname,
+    status: res.statusCode
+  };
+  if (res.statusMessage) {
+    logInfo.errorMessage = res.statusMessage;
+  }
+  inline.log(JSON.stringify(logInfo));
+  next();
 }
-const apiKeyMiddleware = (key) => {
-    async function requireAPIKey(req, res, next) {
-        try {
-            const apiKey = req.get("x-api-key") || req.query["api-key"]; // api key present either in header or query string
-            if (!apiKey) {
-                inline.log("request without api key");
-                res.status(400).send("require x-api-key header");
-                return;
-            }
-            // key can be either a string or a map with multiple keys
-            if (typeof key === "string") {
-                if (apiKey !== key) {
-                    inline.log("request has an invalid api key");
-                    res.status(400).send("invalid api key");
-                    return;
-                }
-                inline.log(`requested by valid key ${key.slice(0, 6)}`);
-            }
-            else {
-                const name = key[apiKey];
-                if (!name) {
-                    inline.log("request has an invalid api key");
-                    res.status(400).send("invalid api key");
-                    return;
-                }
-                inline.log(`requested by authorized user ${name}`);
-            }
-            next();
+var apiKeyMiddleware = (key) => {
+  async function requireAPIKey(req, res, next) {
+    try {
+      const apiKey = req.get("x-api-key") || req.query["api-key"];
+      if (!apiKey) {
+        inline.log("request without api key");
+        res.status(400).send("require x-api-key header");
+        return;
+      }
+      if (typeof key === "string") {
+        if (apiKey !== key) {
+          inline.log("request has an invalid api key");
+          res.status(400).send("invalid api key");
+          return;
         }
-        catch (err) {
-            inline.log("check api key error", err);
-            res.status(500).send("internal error");
+        inline.log(`requested by valid key ${key.slice(0, 6)}`);
+      } else {
+        const name = key[apiKey];
+        if (!name) {
+          inline.log("request has an invalid api key");
+          res.status(400).send("invalid api key");
+          return;
         }
+        inline.log(`requested by authorized user ${name}`);
+      }
+      next();
+    } catch (err) {
+      inline.log("check api key error", err);
+      res.status(500).send("internal error");
     }
-    return requireAPIKey;
+  }
+  return requireAPIKey;
 };
-export async function startApiApp({ binaryName, name, selector = {}, routes, serve, beforeListen, }) {
-    const app = express();
-    app.use(express.json({ limit: "20mb" }));
-    const cli = meow(`
+async function startApiApp({
+  binaryName,
+  name,
+  selector = {},
+  routes,
+  serve,
+  beforeListen
+}) {
+  const app = express();
+  app.use(express.json({ limit: "20mb" }));
+  const cli = meow(`
         Usage
           $ ${binaryName} <options>
 
@@ -83,64 +199,63 @@ export async function startApiApp({ binaryName, name, selector = {}, routes, ser
 ${getSelectorDesc(selector)}
           --verbose       Output debug messages
       `, {
-        importMeta: import.meta,
-        description: false,
-        version: false,
-        flags: {
-            ...getSelectorFlags(selector),
-            verbose: {
-                type: "boolean",
-                default: false,
-            },
-        },
-    });
-    const { verbose, ...selectorFlags } = cli.flags;
-    for (const route of routes) {
-        const method = route.method ? route.method.toLowerCase() : "get";
-        const middlewares = route.middlewares || [];
-        if (route.protected) {
-            if (!serve.apiKey) {
-                throw new Error("serve.apiKey is required for protected route");
-            }
-            middlewares.unshift(apiKeyMiddleware(serve.apiKey));
-        }
-        if (app[method]) {
-            if (verbose) {
-                inline.log(`registering ${method} ${route.path}`);
-            }
-            app[method](route.path, contextMiddleware, logStartMiddleware, ...middlewares, async (req, res, next) => {
-                try {
-                    await route.handler({ req, res, ...selectorFlags });
-                }
-                catch (routeErr) {
-                    if (routeErr instanceof Error) {
-                        inline.log("caught route err", routeErr, routeErr.stack);
-                        res.status(500).send(`internal server error: ${routeErr.message}`);
-                    }
-                    else {
-                        inline.log("caught route err", routeErr);
-                        res.status(500).send("internal server error");
-                    }
-                }
-                next();
-            }, logEndMiddleware);
-        }
+    importMeta: import.meta,
+    description: false,
+    version: false,
+    flags: {
+      ...getSelectorFlags(selector),
+      verbose: {
+        type: "boolean",
+        default: false
+      }
     }
-    if (!routes.some((r) => r.path === "/" && r.method?.toUpperCase() === "GET")) {
-        // for health check
-        app.get("/", (_, res) => {
-            res.send("ok");
-        });
+  });
+  const { verbose, ...selectorFlags } = cli.flags;
+  for (const route of routes) {
+    const method = route.method ? route.method.toLowerCase() : "get";
+    const middlewares = route.middlewares || [];
+    if (route.protected) {
+      if (!serve.apiKey) {
+        throw new Error("serve.apiKey is required for protected route");
+      }
+      middlewares.unshift(apiKeyMiddleware(serve.apiKey));
     }
-    if (beforeListen) {
-        await beforeListen({ app });
-    }
-    app.listen(serve.port, () => {
-        if (isProduction()) {
-            inline.log(`${name} listening at https://api.wf.corp.certik.com${serve.prefix}`);
-        }
-        else {
-            inline.log(`${name} listening at http://localhost:${serve.port}`);
+    if (app[method]) {
+      if (verbose) {
+        inline.log(`registering ${method} ${route.path}`);
+      }
+      app[method](route.path, contextMiddleware, logStartMiddleware, ...middlewares, async (req, res, next) => {
+        try {
+          await route.handler({ req, res, ...selectorFlags });
+        } catch (routeErr) {
+          if (routeErr instanceof Error) {
+            inline.log("caught route err", routeErr, routeErr.stack);
+            res.status(500).send(`internal server error: ${routeErr.message}`);
+          } else {
+            inline.log("caught route err", routeErr);
+            res.status(500).send("internal server error");
+          }
         }
+        next();
+      }, logEndMiddleware);
+    }
+  }
+  if (!routes.some((r) => r.path === "/" && r.method?.toUpperCase() === "GET")) {
+    app.get("/", (_, res) => {
+      res.send("ok");
     });
+  }
+  if (beforeListen) {
+    await beforeListen({ app });
+  }
+  app.listen(serve.port, () => {
+    if (isProduction()) {
+      inline.log(`${name} listening at https://api.wf.corp.certik.com${serve.prefix}`);
+    } else {
+      inline.log(`${name} listening at http://localhost:${serve.port}`);
+    }
+  });
 }
+export {
+  startApiApp
+};

package/dist/app.d.ts

@@ -74,7 +74,7 @@ declare function api({ name, routes, serve, beforeListen, env, region, }: {
     env?: Env;
     region?: string;
 }): () => Promise<void>;
-declare const SENSITIVE_VALUE: any;
+declare const SENSITIVE_VALUE: null;
 declare const every: (n?: number) => {
     second: string;
     seconds: string;
@@ -99,4 +99,3 @@ declare const every: (n?: number) => {
     weeks?: undefined;
 };
 export { indexer, modeIndexer, api, every, SENSITIVE_VALUE };
-//# sourceMappingURL=app.d.ts.map