@upstart.gg/sdk 0.0.104 → 0.0.106

package/src/node/cli/program.ts

@@ -1,77 +0,0 @@
-#!/usr/bin/env node
-import { program, type Command, type OptionValues } from "commander";
-import type { BuildOptions, CommonOptions } from "./types";
-import { publish } from "./commands/publish/cmd-publish";
-import { login } from "./commands/login/cmd-login";
-import { buildTemplate } from "./commands/cmd-build";
-import { createLogger, type Logger } from "../shared/logger";
-import { logout } from "./commands/logout/cmd-logout";
-
-let logger: Logger;
-
-program
-  .name("enpage")
-  .option("-l, --logLevel <level>", `[string] info | warn | error | silent | debug`)
-  .option("--clearScreen", `[boolean] allow/disable clear screen when logging`)
-  .option("--dry-run", `[boolean] run command without making changes`)
-  .hook("preAction", (thisCommand) => {
-    logger = createLogger(
-      thisCommand.optsWithGlobals().logLevel,
-      thisCommand.optsWithGlobals().clearScreen,
-      true,
-    );
-    // for now, disable the form-data warning until they fix it
-    process.removeAllListeners("warning");
-    process.on("warning", (warning) => {
-      if (warning.name === "DeprecationWarning" && warning.message.includes("util.isArray")) {
-        return;
-      }
-      logger.warnOnce(`Warning: ${warning.name} - ${warning.message}`);
-    });
-  });
-
-program
-  .command("build")
-  .description("Build template")
-  .option(
-    "--ssr [type]",
-    `Enable server side rendering.
-Pass --ssr to generate a SSR-enabled build.
-Pass --ssr=local to generate a SSR-enabled build that can be tested locally.`,
-    Boolean,
-    false,
-  )
-  .option("--no-clean", `Don't clean directory before buidling`)
-  .action(function (this: Command) {
-    buildTemplate(getArgsOptionsObject<BuildOptions>(this));
-  });
-
-program
-  .command("publish")
-  .description("Publish a template to Enpage")
-  .argument("[directory]", "Directory to publish")
-  .option("--no-check", `Don't check for required files`)
-
-  .action(function (this: Command) {
-    publish(getArgsOptionsObject(this));
-  });
-
-program
-  .command("login")
-  .description("Login to Enpage")
-  .action(function (this: Command) {
-    login(getArgsOptionsObject(this));
-  });
-
-program
-  .command("logout")
-  .description("Logout from Enpage")
-  .action(function (this: Command) {
-    logout(getArgsOptionsObject(this));
-  });
-
-program.parse();
-
-function getArgsOptionsObject<O extends OptionValues>(cmd: Command) {
-  return { options: cmd.optsWithGlobals<CommonOptions & O>(), args: cmd.args, logger };
-}

package/src/node/cli/store.ts

@@ -1,64 +0,0 @@
-import type { CredentialsStore } from "./types";
-import { CLI_PROJECT_NAME, OAUTH_ENDPOINT_USER_INFO } from "./constants";
-import Conf from "conf";
-import path from "node:path";
-import crypto from "node:crypto";
-import fs from "node:fs";
-import { fileURLToPath } from "node:url";
-import { getPackageManager } from "./utils";
-import chalk from "chalk";
-
-const __dirname = fileURLToPath(new URL(".", import.meta.url));
-const key = getKey();
-const accessStore = new Conf<CredentialsStore>({
-  projectName: CLI_PROJECT_NAME,
-  encryptionKey: key,
-  clearInvalidConfig: true,
-});
-
-/**
- * Get access token or throw error if not found
- */
-export function getTokenOrThrow() {
-  const token = accessStore.get("access_token");
-  if (!token) {
-    const pkgCmd = getPackageManager();
-    throw new Error(
-      `Access token not found. Please run ${chalk.cyan(`${pkgCmd} run enpage:login`)} to authenticate.`,
-    );
-  }
-  return token;
-}
-
-function findNearestNodeModules(): string | null {
-  let currentDir = __dirname;
-  while (currentDir !== path.parse(currentDir).root) {
-    const nodeModulesPath = path.join(currentDir, "node_modules");
-    if (fs.existsSync(nodeModulesPath)) {
-      return nodeModulesPath;
-    }
-    currentDir = path.dirname(currentDir);
-  }
-  return null;
-}
-
-function getKey() {
-  const nodeModulesPath = findNearestNodeModules();
-  if (!nodeModulesPath) {
-    throw new Error("Could not find nearest node_modules directory.");
-  }
-  const tmpSecureStoreDir = path.join(nodeModulesPath, ".enpage-tmp");
-  if (!fs.existsSync(tmpSecureStoreDir)) {
-    fs.mkdirSync(tmpSecureStoreDir, { recursive: true, mode: 0o700 });
-  }
-  const keyPath = path.join(tmpSecureStoreDir, ".enpage-key");
-  if (!fs.existsSync(keyPath)) {
-    const key = crypto.randomBytes(32).toString("hex");
-    fs.writeFileSync(keyPath, key, { mode: 0o600 });
-    return key;
-  }
-  const key = fs.readFileSync(keyPath, "utf8");
-  return key;
-}
-
-export { accessStore };

package/src/node/cli/tests/api.test.ts

@@ -1,161 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-import { post, get } from "../api";
-import { accessStore } from "../store";
-
-vi.mock("../store", () => ({
-  accessStore: {
-    get: vi.fn(),
-  },
-  getToken: vi.fn(),
-}));
-
-vi.mock("../shared/logger", () => ({
-  logger: {
-    error: vi.fn(),
-  },
-}));
-
-global.fetch = vi.fn();
-
-describe("API functions", () => {
-  beforeEach(() => {
-    vi.resetAllMocks();
-  });
-
-  afterEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  describe("post", () => {
-    it("should make a POST request with correct headers and body", async () => {
-      const mockResponse = { data: "test" };
-      (global.fetch as any).mockResolvedValueOnce({
-        ok: true,
-        status: 200,
-        statusText: "OK",
-        headers: new Headers({ "content-type": "application/json" }),
-        json: () => Promise.resolve(mockResponse),
-      });
-
-      const result = await post("/test", { key: "value" });
-
-      expect(global.fetch).toHaveBeenCalledWith(
-        expect.any(URL),
-        expect.objectContaining({
-          method: "POST",
-          headers: expect.objectContaining({
-            "Content-Type": "application/json",
-          }),
-          body: JSON.stringify({ key: "value" }),
-        }),
-      );
-      expect(result).toEqual({
-        isSuccess: true,
-        isError: false,
-        status: 200,
-        statusText: "OK",
-        data: mockResponse,
-      });
-    });
-
-    it("should handle URLSearchParams correctly", async () => {
-      const mockResponse = { data: "test" };
-      (global.fetch as any).mockResolvedValueOnce({
-        ok: true,
-        status: 200,
-        statusText: "OK",
-        headers: new Headers({ "content-type": "application/json" }),
-        json: () => Promise.resolve(mockResponse),
-      });
-
-      const params = new URLSearchParams({ key: "value" });
-      await post("/test", params);
-
-      expect(global.fetch).toHaveBeenCalledWith(
-        expect.any(URL),
-        expect.objectContaining({
-          headers: expect.objectContaining({
-            "Content-Type": "application/x-www-form-urlencoded",
-          }),
-          body: params,
-        }),
-      );
-    });
-
-    it("should handle error responses", async () => {
-      const errorResponse = { error: "Test error" };
-      (global.fetch as any).mockResolvedValueOnce({
-        ok: false,
-        status: 400,
-        statusText: "Bad Request",
-        headers: new Headers({ "content-type": "application/json" }),
-        json: () => Promise.resolve(errorResponse),
-      });
-
-      const result = await post("/test", { key: "value" });
-
-      expect(result).toEqual({
-        isSuccess: false,
-        isError: true,
-        status: 400,
-        statusText: "Bad Request",
-        data: errorResponse,
-      });
-    });
-  });
-
-  describe("get", () => {
-    it("should make a GET request with correct headers", async () => {
-      const mockResponse = { data: "test" };
-      (global.fetch as any).mockResolvedValueOnce({
-        ok: true,
-        status: 200,
-        statusText: "OK",
-        headers: new Headers({ "content-type": "application/json" }),
-        json: () => Promise.resolve(mockResponse),
-      });
-
-      vi.mocked(accessStore.get).mockReturnValue("test-token");
-
-      const result = await get("/test");
-
-      expect(global.fetch).toHaveBeenCalledWith(
-        expect.any(URL),
-        expect.objectContaining({
-          method: "GET",
-          headers: expect.objectContaining({
-            Authorization: "Bearer test-token",
-          }),
-        }),
-      );
-      expect(result).toEqual({
-        isSuccess: true,
-        isError: false,
-        status: 200,
-        statusText: "OK",
-        data: mockResponse,
-      });
-    });
-
-    it("should handle error responses", async () => {
-      const errorResponse = { error: "Test error" };
-      (global.fetch as any).mockResolvedValueOnce({
-        ok: false,
-        status: 404,
-        statusText: "Not Found",
-        headers: new Headers({ "content-type": "application/json" }),
-        json: () => Promise.resolve(errorResponse),
-      });
-
-      const result = await get("/test");
-
-      expect(result).toEqual({
-        isSuccess: false,
-        isError: true,
-        status: 404,
-        statusText: "Not Found",
-        data: errorResponse,
-      });
-    });
-  });
-});

package/src/node/cli/types.ts

@@ -1,34 +0,0 @@
-import type { OptionValues } from "commander";
-import type { Logger } from "../shared/logger";
-
-export type CredentialsStore = {
-  access_token: string;
-  token_type: string;
-  expires_in?: number;
-  refresh_token?: string;
-  refresh_token_expires_in?: number;
-  scope?: string;
-  expires_at: number;
-};
-
-export type CommandArgOpts<Opts extends OptionValues = OptionValues> = {
-  args: string[];
-  options: CommonOptions & Opts;
-  logger: Logger;
-};
-
-export type CommonOptions = {
-  logLevel?: "info" | "warn" | "error" | "silent";
-  clearScreen?: boolean;
-  dryRun?: boolean;
-};
-
-export type BuildOptions = {
-  ssr: boolean | "local";
-  clean?: boolean;
-};
-
-export type GenericApiError = {
-  error: string;
-  error_description: string;
-};

package/src/node/cli/utils.ts

@@ -1,20 +0,0 @@
-export function getPackageManager() {
-  // Detect package manager
-  let packageManager: string | undefined;
-  if (process.env.npm_config_user_agent) {
-    const pmPart = process.env.npm_config_user_agent.split(" ")[0];
-    packageManager = pmPart.slice(0, pmPart.lastIndexOf("/"));
-  }
-
-  // Display message
-  if (!packageManager) {
-    console.log("Warning: could not detect package manager");
-    packageManager = "npm";
-  }
-
-  return packageManager;
-}
-
-export function formatAPIError(error: { error: string; error_description?: string }) {
-  return `[${error.error}]${error.error_description ? `: ${error.error_description}` : ""}`;
-}

package/src/node/shared/config.ts

@@ -1,69 +0,0 @@
-import fs from "node:fs";
-import { readFile } from "node:fs/promises";
-import fg from "fast-glob";
-import { type Logger, logger as defaultLogger } from "./logger";
-import { basename, dirname, extname } from "node:path";
-import type { SiteAndPagesConfig } from "~/shared/site";
-
-export async function loadConfigFromJsFile(
-  configPath: string,
-  logger = defaultLogger as Logger,
-): Promise<SiteAndPagesConfig> {
-  if (!fs.existsSync(configPath)) {
-    logger.error(
-      "🔴 No enpage.config.js found!\nYour project must have an enpage.config.js file in the root directory.\n\n",
-    );
-    process.exit(1);
-  }
-  const config = (await import(configPath)) as SiteAndPagesConfig;
-
-  // Parse the readme files fro the same directory as the config file
-  const readmePath = dirname(configPath);
-  const readme: Record<string, string> = {};
-  const readmeFiles = await fg(["README.enpage.md", "README.enpage.*.md"], {
-    cwd: readmePath,
-    onlyFiles: true,
-    absolute: true,
-    caseSensitiveMatch: false,
-  });
-
-  for (const file of readmeFiles) {
-    const base = basename(file, ".md");
-    const ext = extname(base);
-    const language = (ext === ".enpage" ? "en" : ext.substring(1)).toLowerCase();
-    logger.debug(`Found template readme file (${language}): ${basename(file)}`);
-    readme[language] = await readFile(file, "utf-8");
-  }
-
-  return config;
-}
-
-export function loadConfigFromManifestFile(manifestPath: string, logger: Logger): SiteAndPagesConfig {
-  if (!fs.existsSync(manifestPath)) {
-    logger.error("🔴 No enpage.manifest.json found!\nYou may want to 'build' your template.\n\n");
-    process.exit(1);
-  }
-  return JSON.parse(fs.readFileSync(manifestPath, "utf-8"));
-}
-
-export function validateTemplateConfig(config: SiteAndPagesConfig, logger: Logger) {
-  for (const key in config.site.datasources) {
-    if (config.site.datasources[key].provider === "http-json" && !config.site.datasources[key].sampleData) {
-      logger.error(
-        `🔴 Error: Datasource "${key}" is missing sample data - nothing will be rendered during development! Please check your enpage.config.js file and add a "sampleData" key to your ${key} datasource.`,
-      );
-      throw new Error(`Missing sample data for datasource "${key}"`);
-    }
-  }
-
-  // Todo: replace validation from zod to ajv
-  // const validated = manifestSchema.safeParse(config.manifest);
-  // if (!validated.success) {
-  //   logger.error(`🔴 Error: template manifest is invalid. Check your call to defineManifest().\n`);
-  //   const err = fromError(validated.error);
-  //   logger.error(`Hint: ${err.toString()}\n\n`);
-  //   process.exit(1);
-  // }
-
-  return config;
-}

package/src/node/shared/logger.ts

@@ -1,44 +0,0 @@
-import {
-  createLogger as createLoggerBase,
-  type LogLevel,
-  type LogOptions,
-  type Logger as BaseLogger,
-} from "vite";
-// import { version } from "../../../package.json";
-import chalk from "chalk";
-
-const VERSION = 0.1;
-
-type UpstartLoggerLevel = LogLevel | "debug";
-
-export function createLogger(level?: UpstartLoggerLevel, allowClearScreen?: boolean, showVersion = false) {
-  // vite logger does not support "debug" level
-  const logger = createLoggerBase(level === "debug" ? "info" : level, {
-    prefix: "[upstart]",
-    allowClearScreen,
-  });
-
-  if (showVersion) {
-    logger.info(chalk.hex("#7270c6").bold(`🚀 Upstart v${VERSION}\n`));
-  }
-
-  return {
-    ...logger,
-    success: (message: string, options?: LogOptions) => logger.info(chalk.green(message), options),
-    error: (message: string, options?: LogOptions) => logger.error(chalk.red(message), options),
-    warn: (message: string, options?: LogOptions) => logger.warn(chalk.yellow(message), options),
-    warnOnce: (message: string, options?: LogOptions) => logger.warnOnce(chalk.yellow(message), options),
-    debug: (message: string, options?: LogOptions) => {
-      if (level === "debug") {
-        logger.info(chalk.gray(message), options);
-      }
-    },
-  };
-}
-
-export const logger = createLogger();
-
-export type Logger = BaseLogger & {
-  success: (message: string, options?: LogOptions) => void;
-  debug: (message: string, options?: LogOptions) => void;
-};

package/src/shared/ajv.ts

@@ -1,103 +0,0 @@
-import Ajv, { type ErrorObject } from "ajv";
-import addFormats from "ajv-formats";
-import { preset } from "./bricks/props/preset";
-import { background, backgroundColor } from "./bricks/props/background";
-import { containerLayout } from "./bricks/props/container";
-import { basicAlign } from "./bricks/props/align";
-import { hidden } from "./bricks/props/common";
-import { border } from "./bricks/props/border";
-import { padding } from "./bricks/props/padding";
-import { image } from "./bricks/props/image";
-import { color } from "./bricks/props/color";
-import { shadow } from "./bricks/props/effects";
-import { textContent } from "./bricks/props/text";
-import { cssLength } from "./bricks/props/css-length";
-import { urlOrPageId } from "./bricks/props/string";
-
-export type { JSONSchemaType, AnySchemaObject, SchemaObject, JSONType } from "ajv";
-
-export const ajv = new Ajv({
-  useDefaults: true,
-  strictSchema: false,
-  validateSchema: false,
-  coerceTypes: true,
-  allErrors: true,
-  inlineRefs: false,
-});
-
-ajv.addSchema(preset(), "styles:preset");
-ajv.addSchema(background(), "styles:background");
-ajv.addSchema(backgroundColor(), "styles:backgroundColor");
-ajv.addSchema(basicAlign(), "styles:basicAlign");
-ajv.addSchema(containerLayout(), "styles:containerLayout");
-ajv.addSchema(hidden(), "styles:hidden");
-ajv.addSchema(border(), "styles:border");
-ajv.addSchema(padding(), "styles:padding");
-ajv.addSchema(color(), "styles:color");
-ajv.addSchema(shadow(), "styles:shadow");
-ajv.addSchema(cssLength(), "styles:cssLength");
-ajv.addSchema(image(), "assets:image");
-ajv.addSchema(textContent(), "content:textContent");
-ajv.addSchema(urlOrPageId(), "content:urlOrPageId");
-
-export const jsonStringsSupportedFormats = [
-  "date-time",
-  "time",
-  "date",
-  "email",
-  "hostname",
-  "ipv4",
-  "ipv6",
-  "uri",
-  "uri-reference",
-  "uuid",
-  "uri-template",
-  "json-pointer",
-  "relative-json-pointer",
-  "regex",
-] as const;
-
-// Add formats to Ajv
-addFormats(ajv, [...jsonStringsSupportedFormats]);
-
-ajv.addFormat("date-object", {
-  // biome-ignore lint/suspicious/noExplicitAny: <explanation>
-  validate: (data: any) => data instanceof Date && !Number.isNaN(data.getTime()),
-  async: false,
-});
-
-ajv.addFormat("richtext", {
-  validate: (data: string) => typeof data === "string",
-  async: false,
-});
-
-ajv.addFormat("markdown", {
-  validate: (data: string) => typeof data === "string",
-  async: false,
-});
-
-ajv.addFormat("multiline", {
-  validate: (data: string) => typeof data === "string",
-  async: false,
-});
-
-ajv.addFormat("password", {
-  validate: (data: string) => typeof data === "string",
-  async: false,
-});
-
-export function serializeAjvErrors(errors: ErrorObject[] | null | undefined): string {
-  if (!errors || errors.length === 0) {
-    return "Unknown validation error";
-  }
-  return errors
-    .map((error) => {
-      const { instancePath, message, params } = error;
-      const path = instancePath || "root";
-      const details = Object.entries(params || {})
-        .map(([key, value]) => `${key}: ${value}`)
-        .join(", ");
-      return `${path} ${message} (${details})`;
-    })
-    .join("; ");
-}

package/src/shared/analytics/init.ts

@@ -1,14 +0,0 @@
-export function init() {
-  window.upstartQueue = window.upstartQueue || [];
-  document.addEventListener("visibilitychange", function logData() {
-    if (document.visibilityState === "hidden") {
-      const payload = JSON.stringify(window.upstartQueue);
-      if (navigator.sendBeacon?.(window.location.pathname, payload)) {
-        console.debug("beacon sent", payload);
-        window.upstartQueue = [];
-      } else {
-        console.debug("beacon failed", payload);
-      }
-    }
-  });
-}

package/src/shared/analytics/track.ts

@@ -1,21 +0,0 @@
-import type { BeaconPayload } from "./types";
-
-export function track(type: BeaconPayload["e"], data: BeaconPayload["d"] = {}) {
-  const payload: BeaconPayload = {
-    e: type,
-    t: Date.now(),
-    d: data,
-  };
-  window.upstartQueue.push(payload);
-}
-
-document.addEventListener(
-  "click",
-  function (e) {
-    const target = e.target as HTMLElement;
-    track("click", {
-      buttonId: target.id,
-    });
-  },
-  true,
-);

package/src/shared/analytics/types.ts

@@ -1,13 +0,0 @@
-type EventType = "click" | "submit" | "custom";
-
-export type BeaconPayload = {
-  e: EventType; // event type
-  t: number; // timestamp
-  d?: Record<string, unknown>; // data
-};
-
-declare global {
-  interface Window {
-    upstartQueue: BeaconPayload[];
-  }
-}