@certik/skynet 0.24.0 → 0.25.0

package/dist/api.js

@@ -1,260 +0,0 @@
-// 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

@@ -1,101 +0,0 @@
-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 };