@squarecloud/api/lib/modules/files.js

A NodeJS wrapper for Square Cloud API

// src/modules/files.ts
import { join } from "path";
import { readFile } from "fs/promises";

// src/lib/routes.ts
var Route = (route) => route;
var Routes = {
  user: () => {
    return Route("users/me");
  },
  service: {
    status: () => {
      return Route("service/status");
    }
  },
  apps: {
    upload: () => {
      return Route("apps");
    },
    statusAll: () => {
      return Route("apps/status");
    },
    info: (appId) => {
      return Route(`apps/${appId}`);
    },
    status: (appId) => {
      return Route(`apps/${appId}/status`);
    },
    logs: (appId) => {
      return Route(`apps/${appId}/logs`);
    },
    delete: (appId) => {
      return Route(`apps/${appId}`);
    },
    commit: (appId) => {
      return Route(`apps/${appId}/commit`);
    },
    snapshots: (appId) => {
      return Route(`apps/${appId}/snapshots`);
    },
    generateSnapshot: (appId) => {
      return Route(`apps/${appId}/snapshots`);
    },
    start: (appId) => {
      return Route(`apps/${appId}/start`);
    },
    restart: (appId) => {
      return Route(`apps/${appId}/restart`);
    },
    stop: (appId) => {
      return Route(`apps/${appId}/stop`);
    },
    files: {
      read: (appId) => {
        return Route(`apps/${appId}/files/content`);
      },
      list: (appId) => {
        return Route(`apps/${appId}/files`);
      },
      upsert: (appId) => {
        return Route(`apps/${appId}/files`);
      },
      move: (appId) => {
        return Route(`apps/${appId}/files`);
      },
      delete: (appId) => {
        return Route(`apps/${appId}/files`);
      }
    },
    deployments: {
      list: (appId) => {
        return Route(`apps/${appId}/deployments`);
      },
      current: (appId) => {
        return Route(
          `apps/${appId}/deployments/current`
        );
      },
      webhook: (appId) => {
        return Route(
          `apps/${appId}/deploy/webhook`
        );
      }
    },
    network: {
      dns: (appId) => {
        return Route(`apps/${appId}/network/dns`);
      },
      custom: (appId) => {
        return Route(`apps/${appId}/network/custom`);
      },
      analytics: (appId) => {
        return Route(
          `apps/${appId}/network/analytics`
        );
      }
    }
  }
};

// src/structures/error.ts
var SquareCloudAPIError = class extends TypeError {
  constructor(code, message, options) {
    super(code);
    this.name = "SquareCloudAPIError";
    this.message = (code?.replaceAll("_", " ").toLowerCase().replace(/(^|\s)\S/g, (L) => L.toUpperCase()) || "UNKNOWN_CODE") + (message ? `: ${message}` : "");
    if (options?.stack) {
      this.stack = options.stack;
    }
    if (options?.cause) {
      this.cause = options.cause;
    }
  }
};

// src/assertions/common.ts
function assert({ validate, value, expect, name }) {
  if (!validate(value)) {
    const code = name ? `INVALID_${name}` : "VALIDATION_ERROR";
    const message = `Expected ${expect}, got ${typeof value}`;
    throw new SquareCloudAPIError(code, message);
  }
}
function makeAssertion(expect, validate) {
  return (value, name) => {
    assert({ validate, value, expect, name });
  };
}

// src/assertions/literal.ts
var assertString = makeAssertion(
  "string",
  (value) => typeof value === "string"
);
var assertBoolean = makeAssertion(
  "boolean",
  (value) => typeof value === "boolean"
);
var assertPathLike = makeAssertion(
  "string or Buffer",
  (value) => typeof value === "string" || value instanceof Buffer
);

// src/modules/files.ts
var FilesModule = class {
  constructor(application) {
    this.application = application;
  }
  /**
   * Lists the files inside a directory
   *
   * @param path - The absolute directory path
   */
  async list(path = "/") {
    assertString(path, "LIST_FILES_PATH");
    const { response } = await this.application.client.api.request(
      Routes.apps.files.list(this.application.id),
      { query: { path } }
    );
    return response;
  }
  /**
   * Reads the specified file content
   *
   * @param path - The absolute file path
   */
  async read(path) {
    assertString(path, "READ_FILE_PATH");
    const { response } = await this.application.client.api.request(
      Routes.apps.files.read(this.application.id),
      { query: { path } }
    );
    if (!response) {
      return;
    }
    return Buffer.from(response.data);
  }
  /**
   * Creates a new file
   *
   * @param file - The file content
   * @param fileName - The file name with extension
   * @param path - The absolute file path
   */
  async create(file, fileName, path = "/") {
    assertPathLike(file, "CREATE_FILE");
    assertString(fileName, "CREATE_FILE_NAME");
    assertString(path, "CREATE_FILE_PATH");
    if (typeof file === "string") {
      file = await readFile(file);
    }
    path = join(path, fileName).replaceAll("\\", "/");
    const { status } = await this.application.client.api.request(
      Routes.apps.files.upsert(this.application.id),
      {
        method: "PUT",
        body: { content: file.toString("utf8"), path }
      }
    );
    return status === "success";
  }
  /**
   * Edits an existing file (same as create)
   *
   * @param file - The file content
   * @param path - The absolute file path
   */
  async edit(file, path = "/") {
    assertPathLike(file, "EDIT_FILE");
    assertString(path, "EDIT_FILE_PATH");
    return this.create(file, "", path);
  }
  /**
   * Moves or renames a file
   *
   * @param path - The current absolute file path
   * @param newPath - The new absolute file path
   */
  async move(path, newPath) {
    assertString(path, "MOVE_FILE_PATH");
    assertString(newPath, "MOVE_FILE_NEW_PATH");
    const { status } = await this.application.client.api.request(
      Routes.apps.files.move(this.application.id),
      { method: "PATCH", body: { path, to: newPath } }
    );
    return status === "success";
  }
  /**
   * Deletes the specified file or directory
   *
   * @param path - The absolute file or directory path
   */
  async delete(path) {
    assertString(path, "DELETE_FILE_PATH");
    const { status } = await this.application.client.api.request(
      Routes.apps.files.delete(this.application.id),
      { method: "DELETE", body: { path } }
    );
    return status === "success";
  }
};
export {
  FilesModule
};
//# sourceMappingURL=files.js.map