@certik/skynet 0.25.0 → 0.25.2

package/dist/address.js

@@ -0,0 +1,24 @@
+// 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];
+}
+function composeAddress(protocol, addr) {
+  return `${protocol}:${addr}`;
+}
+export {
+  parseAddress,
+  composeAddress
+};

package/dist/api.d.ts

@@ -0,0 +1,31 @@
+import express from "express";
+import type { Request, Response, NextFunction } from "express";
+import type { Selector } from "./selector";
+export type Middleware = (req: Request, res: Response, next: NextFunction) => Promise<void>;
+type Route = {
+    method?: "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
+    path: string;
+    middlewares?: Middleware[];
+    handler: (args: {
+        req: Request;
+        res: Response;
+        verbose?: boolean;
+    }) => Promise<void>;
+    protected?: boolean;
+};
+type Serve = {
+    prefix: string;
+    port: number;
+    apiKey?: string | Record<string, string>;
+};
+export declare function startApiApp({ binaryName, name, selector, routes, serve, beforeListen, }: {
+    binaryName: string;
+    name: string;
+    selector?: Selector;
+    routes: Route[];
+    serve: Serve;
+    beforeListen?: (args: {
+        app: ReturnType<typeof express>;
+    }) => Promise<void>;
+}): Promise<void>;
+export {};

package/dist/api.js

@@ -0,0 +1,260 @@
+// 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/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/api.ts
+import osModule from "os";
+import express from "express";
+import meow from "meow";
+async function logStartMiddleware(_, res, 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();
+}
+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));
+  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;
+        }
+        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;
+};
+async function startApiApp({
+  binaryName,
+  name,
+  selector = {},
+  routes,
+  serve,
+  beforeListen
+}) {
+  const app = express();
+  app.use(express.json({ limit: "20mb" }));
+  const cli = meow(`
+        Usage
+          $ ${binaryName} <options>
+
+        Options
+${getSelectorDesc(selector)}
+          --verbose       Output debug messages
+      `, {
+    importMeta: import.meta,
+    description: 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);
+    }
+  }
+  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

@@ -0,0 +1,101 @@
+import type { IndexerStateValue, State, ModeBuildFunction, StatelessBuildFunction, ValidateFunction } from "./indexer";
+import type { Env } from "./deploy";
+import type { Middleware } from "./api";
+import type { Selector } from "./selector";
+import type { Request, Response, Application } from "express";
+type RouteDefinition = {
+    method?: "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
+    path: string;
+    middlewares?: Middleware[];
+    handler: (args: {
+        req: Request;
+        res: Response;
+        verbose?: boolean;
+    }) => Promise<void>;
+    protected?: boolean;
+};
+type ServeDefinition = {
+    prefix: string;
+    port: number;
+    apiKey?: string | Record<string, string>;
+    killTimeout?: string;
+    cpu: number;
+    mem: number;
+    instances?: number;
+};
+type BuildDefinition<TFunc> = {
+    func: TFunc;
+    killTimeout?: string;
+    maxRetry?: number;
+    cpu: number;
+    mem: number;
+    schedule: string;
+    restart?: {
+        attempts: number;
+        mode: string;
+        interval: string;
+        delay: string;
+    };
+    batchSize?: number;
+    concurrency?: number;
+};
+type ValidateDefinition<TFunc> = {
+    func: TFunc;
+    batchSize: number;
+    killTimeout?: string;
+    cpu: number;
+    mem: number;
+    concurrency?: number;
+    schedule: string;
+};
+declare function indexer<TSelector extends Selector>({ name, selector, build, env, region, }: {
+    name: string;
+    selector: TSelector;
+    build: BuildDefinition<StatelessBuildFunction<TSelector>>;
+    env?: Env;
+    region?: string;
+}): () => Promise<void>;
+declare function modeIndexer<T extends IndexerStateValue, TSelector extends Selector>({ name, selector, state, build, validate, env, region, }: {
+    name: string;
+    selector: TSelector;
+    state: State<T, TSelector>;
+    build: BuildDefinition<ModeBuildFunction<T, TSelector>>;
+    validate?: ValidateDefinition<ValidateFunction<TSelector>>;
+    env?: Env;
+    region?: string;
+}): () => Promise<void>;
+declare function api({ name, routes, serve, beforeListen, env, region, }: {
+    name: string;
+    routes: RouteDefinition[];
+    serve: ServeDefinition;
+    beforeListen?: ({ app }: {
+        app: Application;
+    }) => Promise<void>;
+    env?: Env;
+    region?: string;
+}): () => Promise<void>;
+declare const SENSITIVE_VALUE: null;
+declare const every: (n?: number) => {
+    second: string;
+    seconds: string;
+    minute: string;
+    minutes: string;
+    hour: string;
+    hours: string;
+    day: string;
+    days: string;
+    week: string;
+    weeks: string;
+} | {
+    second: string;
+    seconds: string;
+    minute: string;
+    minutes: string;
+    hour: string;
+    hours: string;
+    day: string;
+    days: string;
+    week?: undefined;
+    weeks?: undefined;
+};
+export { indexer, modeIndexer, api, every, SENSITIVE_VALUE };