merge: squarecloud/dev for Square Cloud API v2

Dev

Author: joaotonaco

.npmrc

@@ -0,0 +1 @@
+engine-strict=true

package.json

@@ -1,7 +1,7 @@
 {
   "name": "@squarecloud/api",
-  "version": "2.2.2",
-  "description": "A NodeJS Wrapper for the SquareCloud API",
+  "version": "3.0.0",
+  "description": "A NodeJS wrapper for Square Cloud API",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
   "scripts": {
@@ -13,15 +13,22 @@
     "square",
     "squarecloud",
     "api",
-    "typescript"
+    "typescript",
+    "app",
+    "bot",
+    "website",
+    "host"
   ],
   "author": {
     "name": "bluey#0012",
-    "url": "https://discord.com/users/702529018410303640"
+    "url": "https://github.com/bluee-js"
   },
   "license": "MIT",
+  "engines": {
+    "node": ">=19.0.0"
+  },
   "devDependencies": {
-    "@types/node": "^18.15.11",
+    "@types/node": "^18.15.13",
     "ts-node-dev": "^2.0.0",
     "typescript": "^4.9.5"
   },

src/assertions.ts

@@ -1,55 +1,48 @@
 import z from 'zod';
-import { SquareCloudAPIError } from './ApiManager';
+import SquareCloudAPIError from './structures/error';
+
+const stringSchema = z.coerce.string();
+const booleanSchema = z.coerce.boolean();
+const pathLikeSchema = z.string().or(z.instanceof(Buffer));
 
 export function validateString(
   value: any,
   code?: string,
-  starts: string = ''
+  starts?: string
 ): asserts value is string {
   if (starts) {
     validateString(starts);
   }
 
-  handleParser(
-    () => z.string().parse(value),
-    'Expect string, got ' + typeof value,
-    code
-  );
+  handleParser(stringSchema, value, 'string', code);
 }
 
 export function validateBoolean(
   value: any,
   code?: string
 ): asserts value is boolean {
-  handleParser(
-    () => z.boolean().parse(value),
-    'Expect boolean, got ' + typeof value,
-    code
-  );
+  handleParser(booleanSchema, value, 'boolean', code);
 }
 
 export function validatePathLike(
   value: any,
   code?: string
 ): asserts value is string | Buffer {
-  handleParser(
-    () => {
-      z.string()
-        .or(z.custom((value) => value instanceof Buffer))
-        .parse(value);
-    },
-    'Expect string or Buffer, got ' + typeof value,
-    code
-  );
+  handleParser(pathLikeSchema, value, 'string or Buffer', code);
 }
 
-function handleParser(func: any, message: string, code?: string) {
+function handleParser(
+  schema: z.Schema,
+  value: any,
+  expect: string,
+  code?: string
+) {
   try {
-    func();
+    schema.parse(value);
   } catch {
     throw new SquareCloudAPIError(
       code ? `INVALID_${code}` : 'VALIDATION_ERROR',
-      message
+      `Expect ${expect}, got ${typeof value}`
     );
   }
 }

src/index.ts

@@ -1,140 +1,39 @@
-import FormData from 'form-data';
-import { readFile } from 'fs/promises';
-import { ApiManager, SquareCloudAPIError } from './ApiManager';
-import { validatePathLike, validateString } from './Assertions';
-import { Application } from './structures/Application';
-import { FullUser, User } from './structures/User';
-import { Options } from './typings';
-
-class SquareCloudAPI {
+import { validateString } from './assertions';
+import APIManager from './managers/api';
+import ApplicationManager from './managers/application';
+import ExperimentalManager from './managers/experimental';
+import UserManager from './managers/user';
+import { APIOptions } from './types';
+
+export class SquareCloudAPI {
   static apiInfo = {
-    version: 'v1',
+    latestVersion: 'v2',
     baseUrl: 'https://api.squarecloud.app/',
   };
 
-  private apiManager: ApiManager;
-  private experimental?: boolean;
+  private apiManager: APIManager;
+
+  /** Use experimental features */
+  public experimental?: ExperimentalManager;
+  /** The applications manager */
+  public applications: ApplicationManager;
+  /** The users manager */
+  public users: UserManager;
 
   /**
    * Creates an API instance
    *
    * @param apiKey - Your API Token (generate at [Square Cloud Dashboard](https://squarecloud.app/dashboard))
-   * @param options.customApiManager - Custom API manager. Just use if you know what you are doing!
    * @param options.experimental - Whether to enable experimental features
    */
-  constructor(apiKey: string, options?: Options) {
+  constructor(apiKey: string, options?: APIOptions) {
     validateString(apiKey, 'API_KEY');
 
-    this.apiManager = new ApiManager(apiKey);
-    this.experimental = Boolean(options?.experimental);
-  }
-
-  /**
-   * Gets a user's informations
-   *
-   * @param userId - The user ID, if not provided it will get your own information
-   */
-  async getUser(): Promise<FullUser>;
-  async getUser(userId: string): Promise<User>;
-  async getUser(userId?: string): Promise<User> {
-    if (userId) {
-      validateString(userId, 'USER_ID');
-    }
-
-    const data = await this.apiManager.user(userId);
-    const hasAccess = data.user.email && data.user.email !== 'Access denied';
-
-    return new (hasAccess ? FullUser : User)(this.apiManager, data);
-  }
-
-  /**
-   * Returns an application that you can manage or get information
-   *
-   * @param appId - The application ID, you must own the application
-   */
-  async getApplication(appId: string): Promise<Application> {
-    validateString(appId, 'APP_ID');
-
-    const data = await this.apiManager.user();
-    const applications = data.applications || [];
-    const applicaton = applications.find((app) => app.id === appId);
-
-    if (!applicaton) {
-      throw new SquareCloudAPIError('APP_NOT_FOUND');
-    }
-
-    return new Application(this.apiManager, applicaton);
-  }
-
-  /**
-   * Upload a new application to Square Cloud
-   *
-   * - Don't forget the [configuration file](https://config.squarecloud.app/).
-   * - This only accepts .zip files.
-   *
-   * - Tip: use this to get an absolute path.
-   * ```ts
-   * require('path').join(__dirname, 'fileName')
-   * ```
-   *
-   * @param file - Buffer or absolute path to the file
-   *
-   * @returns The uploaded application ID
-   */
-  async uploadApplication(file: string | Buffer) {
-    validatePathLike(file, 'UPLOAD_DATA');
-
-    if (typeof file === 'string') {
-      file = await readFile(file);
-    }
-
-    const formData = new FormData();
-    formData.append('file', file, { filename: 'app.zip' });
-
-    const data = await this.apiManager.fetch('upload', {
-      method: 'POST',
-      body: formData.getBuffer(),
-      headers: formData.getHeaders(),
-    });
-
-    return <string>data?.app?.id;
-  }
-
-  /**
-   * @experimental
-   * Use the new Square Cloud experimental AI feature.
-   * **May have bugs.**
-   *
-   * @param question - The question you want to be answered :)
-   * @param prompt - Optional context or previous messages
-   */
-  async askAi(question: string, prompt?: string): Promise<string | undefined> {
-    if (!this.experimental) {
-      return;
-    }
-
-    const data = await this.apiManager.fetch(
-      'ai',
-      {
-        method: 'POST',
-        body: JSON.stringify({ question, prompt }),
-      },
-      'experimental'
-    );
-
-    return data?.response;
+    this.apiManager = new APIManager(apiKey);
+    this.experimental = options?.experimental
+      ? new ExperimentalManager(this.apiManager)
+      : undefined;
+    this.applications = new ApplicationManager(this.apiManager);
+    this.users = new UserManager(this.apiManager);
   }
 }
-
-module.exports = Object.assign(SquareCloudAPI, {
-  default: SquareCloudAPI,
-  ApiManager,
-  Application,
-  FullUser,
-  User,
-});
-
-export default SquareCloudAPI;
-export * from './typings';
-export { ApiManager, Application, FullUser, User };
-

src/managers/api.ts

@@ -0,0 +1,54 @@
+import SquareCloudAPIError from '../structures/error';
+import { APIRootPath, APIVersion, UserResponse } from '../types';
+import { APIResponse } from '../types';
+
+export default class APIManager {
+  public readonly baseUrl = 'https://api.squarecloud.app';
+
+  constructor(readonly apiKey: string) {}
+
+  user(userId?: string): Promise<APIResponse<UserResponse>> {
+    return this.fetch('user' + (userId ? `/${userId}` : ''));
+  }
+
+  application(
+    path: string,
+    appId: string,
+    options?: RequestInit | 'GET' | 'POST' | 'DELETE'
+  ): Promise<APIResponse> {
+    if (typeof options === 'string') {
+      options = {
+        method: options,
+      };
+    }
+
+    return this.fetch(`apps/${appId}/${path}`, options);
+  }
+
+  async fetch(
+    path: string,
+    options: RequestInit = {},
+    version: APIVersion<1 | 2> = 'v2',
+    rootPath?: APIRootPath
+  ): Promise<APIResponse> {
+    options = {
+      ...options,
+      method: options.method || 'GET',
+      headers: { ...(options.headers || {}), Authorization: this.apiKey },
+    };
+
+    const res = await fetch(
+      `${this.baseUrl}/${version}${rootPath ? `/${rootPath}` : ''}/${path}`,
+      options
+    ).catch((err) => {
+      throw new SquareCloudAPIError(err.code);
+    });
+    const data = await res.json();
+
+    if (!data || data.status === 'error' || !res.ok) {
+      throw new SquareCloudAPIError(data?.code || 'COMMON_ERROR');
+    }
+
+    return data;
+  }
+}

src/managers/application.ts

@@ -0,0 +1,64 @@
+import FormData from 'form-data';
+import { readFile } from 'fs/promises';
+import { validatePathLike, validateString } from '../assertions';
+import Application from '../structures/application';
+import Collection from '../structures/collection';
+import { FullUser } from '../structures/user';
+import { APIResponse, UploadedApplicationResponse } from '../types';
+import APIManager from './api';
+
+export default class ApplicationManager {
+  constructor(private readonly apiManager: APIManager) {}
+
+  /**
+   * If the ID is provided, it will return an application that you can manage or get information
+   * If the ID is not provided, it will return a collection of applications
+   *
+   * @param appId - The application ID, you must own the application
+   */
+  async get(): Promise<Collection<string, Application> | undefined>;
+  async get(appId: string): Promise<Application | undefined>;
+  async get(
+    appId?: string
+  ): Promise<Application | Collection<string, Application> | undefined> {
+    const { response } = await this.apiManager.user();
+    if (!response) {
+      return;
+    }
+
+    const { applications } = new FullUser(this.apiManager, response);
+
+    if (appId) {
+      validateString(appId, 'APP_ID');
+      return applications.get(appId);
+    }
+    return applications;
+  }
+
+  /**
+   * Uploads an application
+   *
+   * @param file - The zip file path or Buffer
+   * @returns The uploaded application data
+   */
+  async create(file: string | Buffer) {
+    validatePathLike(file, 'COMMIT_DATA');
+
+    if (typeof file === 'string') {
+      file = await readFile(file);
+    }
+
+    const formData = new FormData();
+    formData.append('file', file, { filename: 'app.zip' });
+
+    const data = <APIResponse<UploadedApplicationResponse>>(
+      await this.apiManager.fetch('apps/upload', {
+        method: 'POST',
+        body: formData.getBuffer(),
+        headers: formData.getHeaders(),
+      })
+    );
+
+    return data?.response?.app;
+  }
+}