zudoku 0.1.1-dev.18 → 0.1.1-dev.19

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "zudoku",
-  "version": "0.1.1-dev.18",
+  "version": "0.1.1-dev.19",
   "type": "module",
   "files": [
     "dist",
     "lib",
     "cli.js",
-    "src/app"
+    "src"
   ],
   "module": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -40,6 +40,9 @@
     },
     "./app/*": {
       "import": "./src/app/*"
+    },
+    "./open-api-worker": {
+      "import": "./lib/zudoku.openapi-worker.js"
     }
   },
   "dependencies": {

package/src/cli/build/handler.ts

@@ -0,0 +1,14 @@
+import { runBuild } from "../../vite/build.js";
+import { printDiagnosticsToConsole } from "../common/output.js";
+
+export interface Arguments {
+  dir: string;
+}
+
+export async function build(argv: Arguments) {
+  printDiagnosticsToConsole("Starting build");
+  printDiagnosticsToConsole("");
+  printDiagnosticsToConsole("");
+
+  await runBuild({ dir: argv.dir });
+}

package/src/cli/cli.ts

@@ -0,0 +1,77 @@
+// import * as dotenv from "dotenv";
+// dotenv.config();
+
+import * as Sentry from "@sentry/node";
+import { readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+
+import { gte } from "semver";
+import { hideBin } from "yargs/helpers";
+import yargs from "yargs/yargs";
+import build from "./cmds/build.js";
+import dev from "./cmds/dev.js";
+import { shutdownAnalytics } from "./common/analytics/lib.js";
+import { MAX_WAIT_PENDING_TIME_MS, SENTRY_DSN } from "./common/constants.js";
+import { logger } from "./common/logger.js";
+import { warnIfOutdatedVersion } from "./common/outdated.js";
+import { printCriticalFailureToConsoleAndExit } from "./common/output.js";
+
+const MIN_NODE_VERSION = "18.0.0";
+
+if (gte(process.versions.node, MIN_NODE_VERSION)) {
+  let packageJson;
+  try {
+    packageJson = JSON.parse(
+      readFileSync(
+        fileURLToPath(new URL("../../package.json", import.meta.url)),
+        "utf-8",
+      ),
+    );
+  } catch (e) {
+    logger.error(e);
+    await printCriticalFailureToConsoleAndExit(
+      `Unable to load zudoku cli. The package.json is missing or malformed.`,
+    );
+  }
+
+  if (SENTRY_DSN) {
+    Sentry.init({
+      dsn: SENTRY_DSN,
+      release: packageJson?.version,
+    });
+  }
+
+  const cli = yargs(hideBin(process.argv))
+    .command(build)
+    .command(dev)
+    .demandCommand()
+    .strictCommands()
+    .version(packageJson?.version)
+    .fail(false)
+    .help();
+
+  try {
+    await cli.argv;
+
+    // Don't block
+    void warnIfOutdatedVersion(packageJson?.version);
+
+    void Sentry.close(MAX_WAIT_PENDING_TIME_MS).then(() => {
+      process.exit(0);
+    });
+  } catch (err) {
+    if (err instanceof Error) {
+      Sentry.captureException(err);
+    }
+    await printCriticalFailureToConsoleAndExit(err.message ?? err);
+    cli.showHelp();
+  } finally {
+    await shutdownAnalytics();
+  }
+} else {
+  await printCriticalFailureToConsoleAndExit(
+    `The zup CLI requires at least node.js v${MIN_NODE_VERSION}. You are using v${process.versions.node}. Please update your version of node.js.
+
+    Consider using a Node.js version manager such as https://github.com/nvm-sh/nvm.`,
+  );
+}

package/src/cli/cmds/build.ts

@@ -0,0 +1,24 @@
+import { Argv } from "yargs";
+import { Arguments, build } from "../build/handler.js";
+import { captureEvent } from "../common/analytics/lib.js";
+
+export default {
+  desc: "Build",
+  command: "build",
+  builder: (yargs: Argv): Argv<unknown> => {
+    return yargs.option("dir", {
+      type: "string",
+      describe: "The directory containing your project",
+      default: ".",
+      normalize: true,
+      hidden: true,
+    });
+  },
+  handler: async (argv: unknown) => {
+    await captureEvent({
+      argv,
+      event: "zudoku build",
+    });
+    await build(argv as Arguments);
+  },
+};

package/src/cli/cmds/dev.ts

@@ -0,0 +1,29 @@
+import { Argv } from "yargs";
+import { captureEvent } from "../common/analytics/lib.js";
+import { Arguments, dev } from "../dev/handler.js";
+
+export default {
+  desc: "Runs locally",
+  command: "dev",
+  builder: (yargs: Argv): Argv<unknown> => {
+    return yargs
+      .option("dir", {
+        type: "string",
+        describe: "The directory containing your project",
+        default: ".",
+        normalize: true,
+        hidden: true,
+      })
+      .option("port", {
+        type: "number",
+        describe: "The port to run the local server on",
+      });
+  },
+  handler: async (argv: unknown) => {
+    await captureEvent({
+      argv,
+      event: "zudoku dev",
+    });
+    await dev(argv as Arguments);
+  },
+};

package/src/cli/common/analytics/lib.ts

@@ -0,0 +1,89 @@
+// import { Context } from "@sentry/node/types/integrations/context.js";
+import { PostHog } from "posthog-node";
+import { POST_HOG_CAPTURE_KEY } from "../constants.js";
+import { machineId } from "../machine-id/lib.js";
+
+interface IdentifyMessageV1 {
+  distinctId: string;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  properties?: Record<string | number, any>;
+  disableGeoip?: boolean;
+}
+
+interface EventMessageV1 extends IdentifyMessageV1 {
+  event: string;
+  groups?: Record<string, string | number>;
+  sendFeatureFlags?: boolean;
+  timestamp?: Date;
+}
+
+interface ZuploEventMessage extends Omit<EventMessageV1, "distinctId"> {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  argv: any;
+}
+
+let _postHog: PostHog | undefined;
+// let _context: Context | undefined;
+
+function init(): PostHog | undefined {
+  if (process.env.ZUPLO_DO_NOT_TRACK || !POST_HOG_CAPTURE_KEY) {
+    return undefined;
+  }
+
+  _postHog = new PostHog(POST_HOG_CAPTURE_KEY, {
+    host: "https://app.posthog.com",
+    flushAt: 1,
+    flushInterval: 1,
+  });
+
+  // // Use the additional information from sentry for the OS, CPU, etc
+  // // This is a bit of a hack since this is not an official API from sentry
+  // _context = (
+  //   getDefaultIntegrations({}).filter(
+  //     (integration) => integration.name == "Context",
+  //   ) as Context[]
+  // )[0];
+
+  return _postHog;
+}
+
+// A convenience wrapper so that callers do not have to inject the distincId for each call to capture
+export async function captureEvent({
+  event,
+  properties,
+  groups,
+  sendFeatureFlags,
+  timestamp,
+  disableGeoip,
+}: ZuploEventMessage): Promise<void> {
+  if (_postHog === undefined) {
+    init();
+  }
+
+  if (_postHog) {
+    properties = properties ?? {};
+    properties.$set_once = properties.$set_once ?? {};
+
+    // Nice to have: set information if this is in CI
+    if (process.env.CI) {
+      properties["ci"] = process.env.CI;
+    }
+
+    // // Nice to have: set information about the machine
+    // await _context?.addContext(properties);
+
+    _postHog?.capture({
+      distinctId: machineId(),
+      event,
+      properties,
+      groups,
+      sendFeatureFlags,
+      timestamp,
+      disableGeoip,
+    });
+  }
+}
+
+export async function shutdownAnalytics(): Promise<void> {
+  return _postHog?.shutdown();
+}

package/src/cli/common/constants.ts

@@ -0,0 +1,10 @@
+// Configuration
+export const CLI_XDG_FOLDER_NAME = "zudoku";
+export const VERSION_CHECK_FILE = "version.json";
+
+// Sentry
+export const SENTRY_DSN = undefined;
+export const MAX_WAIT_PENDING_TIME_MS = 1000;
+
+// PostHog
+export const POST_HOG_CAPTURE_KEY = undefined;

package/src/cli/common/logger.ts

@@ -0,0 +1,5 @@
+import { LogLevel, createLogger } from "vite";
+
+export const logger = createLogger(
+  (process.env.LOG_LEVEL || "info") as LogLevel,
+);

package/src/cli/common/machine-id/lib.ts

@@ -0,0 +1,85 @@
+/**
+ * node-machine-id
+ * Copyright (c) 2016 Aleksandr Komlev
+ * MIT Licensed
+ *
+ * From https://github.com/automation-stack/node-machine-id
+ */
+import { execSync } from "node:child_process";
+import { createHash } from "node:crypto";
+
+const win32RegBinPath = {
+  skipped: "",
+  native: "%windir%\\System32",
+  mixed: "%windir%\\sysnative\\cmd.exe /c %windir%\\System32",
+};
+const guid = {
+  darwin: "ioreg -rd1 -c IOPlatformExpertDevice",
+  win32:
+    `${
+      win32RegBinPath[isWindowsProcessMixedOrNativeArchitecture()]
+    }\\REG.exe ` +
+    "QUERY HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Cryptography " +
+    "/v MachineGuid",
+  linux:
+    "( cat /var/lib/dbus/machine-id /etc/machine-id 2> /dev/null || hostname ) | head -n 1 || :",
+};
+
+function isWindowsProcessMixedOrNativeArchitecture():
+  | "skipped"
+  | "mixed"
+  | "native" {
+  // detect if the node binary is the same arch as the Windows OS.
+  // or if this is 32 bit node on 64 bit windows.
+  if (process.platform !== "win32") {
+    return "skipped";
+  }
+  if (process.arch === "ia32" && process.env["PROCESSOR_ARCHITEW6432"]) {
+    return "mixed";
+  }
+  return "native";
+}
+
+function hash(guid: string): string {
+  return createHash("sha256").update(guid).digest("hex");
+}
+
+function expose(result: string): string {
+  switch (process.platform) {
+    case "darwin":
+      return result
+        .split("IOPlatformUUID")[1]
+        .split("\n")[0]
+        .replace(/=|\s+]"/gi, "")
+        .toLowerCase();
+    case "win32":
+      return result
+        .toString()
+        .split("REG_SZ")[1]
+        .replace(/\r+|\n+|\s+/gi, "")
+        .toLowerCase();
+    case "linux":
+      return result
+        .toString()
+        .replace(/\r+|\n+|\s+/gi, "")
+        .toLowerCase();
+    case "freebsd":
+      return result
+        .toString()
+        .replace(/\r+|\n+|\s+/gi, "")
+        .toLowerCase();
+    default:
+      throw new Error(`Unsupported platform: ${process.platform}`);
+  }
+}
+
+export function machineId(): string {
+  switch (process.platform) {
+    case "darwin":
+    case "win32":
+    case "linux":
+      return hash(expose(execSync(guid[process.platform]).toString()));
+    default:
+      return "e16fc483-5593-4d71-b485-a6533693da9b";
+  }
+}

package/src/cli/common/outdated.ts

@@ -0,0 +1,102 @@
+import chalk from "chalk";
+import { existsSync, mkdirSync } from "node:fs";
+import { readFile, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { gt } from "semver";
+import { VERSION_CHECK_FILE } from "./constants.js";
+import { printWarningToConsole } from "./output.js";
+import box from "./utils/box.js";
+import { ZUPLO_XDG_STATE_HOME } from "./xdg/lib.js";
+
+interface VersionCheckInfo {
+  lastCheck: number;
+  latestVersion: string;
+}
+export async function warnIfOutdatedVersion(currentVersion: string) {
+  // Print update information, if available
+  if (
+    !process.env.ZUPLO_OVERRIDE_CI_TO_TEST &&
+    (process.env.CI || process.env.ZUPLO_DISABLE_UPDATE_CHECK)
+  ) {
+    return false;
+  }
+  const versionCheckInfo = await getVersionCheckInfo();
+  const shouldWarn = gt(versionCheckInfo.latestVersion, currentVersion);
+
+  if (shouldWarn) {
+    printWarningToConsole(
+      box(
+        `Update available! ${chalk.gray(`v${currentVersion}`)} ≫ ${chalk.green(
+          `v${versionCheckInfo.latestVersion}`,
+        )}
+Run ${chalk.cyan("npm install zuplo@latest")} to update.
+
+${chalk.gray("Older versions are unsupported and may not work as expected.")}`,
+      ),
+    );
+  }
+
+  return shouldWarn;
+}
+
+async function getLatestVersion(): Promise<string> {
+  const response = await fetch(
+    "https://raw.githubusercontent.com/zuplo/zudoku/main/packages/zudoku/package.json",
+  );
+  const result = await response.json();
+
+  return result.dependencies["zudoku"];
+}
+
+async function getVersionCheckInfo(): Promise<VersionCheckInfo> {
+  if (!existsSync(ZUPLO_XDG_STATE_HOME)) {
+    mkdirSync(ZUPLO_XDG_STATE_HOME, { recursive: true });
+  }
+  const versionCheckPath = join(ZUPLO_XDG_STATE_HOME, VERSION_CHECK_FILE);
+
+  let versionCheckInfo: VersionCheckInfo | undefined;
+  if (existsSync(versionCheckPath)) {
+    try {
+      versionCheckInfo = await readFile(versionCheckPath, "utf-8").then(
+        JSON.parse,
+      );
+    } catch (err) {
+      // Error reading or parsing file, ignore it
+    }
+
+    // Check if the file is valid, if not ignore it
+    if (versionCheckInfo) {
+      if (
+        typeof versionCheckInfo.lastCheck !== "number" ||
+        typeof versionCheckInfo.latestVersion !== "string"
+      ) {
+        versionCheckInfo = undefined;
+      }
+    }
+  }
+
+  let shouldCheck = true;
+  if (versionCheckInfo) {
+    const now = Date.now();
+    const lastCheck = versionCheckInfo.lastCheck;
+    if (now - lastCheck < 1000 * 60 * 60 * 24) {
+      shouldCheck = false;
+    }
+  }
+
+  if (!versionCheckInfo || shouldCheck) {
+    const latestVersion = await getLatestVersion();
+
+    versionCheckInfo = {
+      lastCheck: Date.now(),
+      latestVersion,
+    };
+    await writeFile(
+      versionCheckPath,
+      JSON.stringify(versionCheckInfo),
+      "utf-8",
+    );
+  }
+
+  return versionCheckInfo;
+}

package/src/cli/common/output.ts

@@ -0,0 +1,86 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable no-console */
+
+import * as Sentry from "@sentry/node";
+import chalk from "chalk";
+import { MAX_WAIT_PENDING_TIME_MS } from "./constants.js";
+
+// We standardize printing to the terminal with this module
+
+// According to https://unix.stackexchange.com/questions/331611/do-progress-reports-logging-information-belong-on-stderr-or-stdout
+// any diagnostic information should go to stderr, and only the actual output goes to stdout
+export function printDiagnosticsToConsole(message?: any) {
+  console.error(chalk.bold.blue(message));
+}
+
+export function printWarningToConsole(message?: any) {
+  console.error(message);
+}
+
+// This information is displayed to the user, so it should be actionable.
+export async function printCriticalFailureToConsoleAndExit(message?: any) {
+  console.error(chalk.bold.red(message));
+  await Sentry.close(MAX_WAIT_PENDING_TIME_MS).then(() => {
+    process.exit(1);
+  });
+}
+
+// Only use this to output the actual result of a command
+// This outputs to STDOUT, which is reserved for the actual result of a command
+export function printResultToConsole(message?: any) {
+  console.log(chalk.bold.green(message));
+}
+
+// Only use this to output the actual result of a command
+// This outputs to STDOUT, which is reserved for the actual result of a command
+export function printTableToConsole(table: any) {
+  console.table(table);
+}
+
+export async function printResultToConsoleAndExitGracefully(message?: any) {
+  printResultToConsole(message);
+  await Sentry.close(MAX_WAIT_PENDING_TIME_MS).then(() => {
+    process.exit(0);
+  });
+}
+
+export async function printTableToConsoleAndExitGracefully(table: any) {
+  printTableToConsole(table);
+  await Sentry.close(MAX_WAIT_PENDING_TIME_MS).then(() => {
+    process.exit(0);
+  });
+}
+
+// See https://nodejs.org/docs/latest-v18.x/api/process.html#a-note-on-process-io
+// We want to deliberately have STDOUT flush synchronously, so we can pipe the output to another command
+
+interface WriteStreamWithHandle {
+  _handle: {
+    // eslint-disable-next-line @typescript-eslint/ban-types
+    setBlocking: Function;
+  };
+  isTTY: boolean;
+}
+
+export default function setBlocking() {
+  // Deno and browser have no process object:
+  if (typeof process === "undefined") return;
+  [process.stdout, process.stderr].forEach((_stream) => {
+    const stream = _stream as any as WriteStreamWithHandle;
+    if (
+      stream._handle &&
+      stream.isTTY &&
+      typeof stream._handle.setBlocking === "function"
+    ) {
+      stream._handle.setBlocking(true);
+    }
+  });
+}
+
+export function textOrJson(text: string) {
+  try {
+    return JSON.parse(text);
+  } catch (e) {
+    return text;
+  }
+}