Merge branch 'alpha' into ts-docs

Author: dplewis

.github/workflows/ci.yml

@@ -30,7 +30,7 @@ jobs:
       - name: Type Definition Check
         run: npm run ci:typecheck
       - name: Test Types
-        run: npm run test:types 2>&1 | tee silent.txt;
+        run: npm run test:types
   check-docs:
     name: Check Docs
     timeout-minutes: 10

eslint.config.test.mjs

@@ -14,15 +14,11 @@ export default tseslint.config({
     '@typescript-eslint': tseslint.plugin,
   },
   rules: {
-    'no-empty': 'off',
     '@typescript-eslint/no-unused-vars': 'off',
     '@typescript-eslint/no-unused-expressions': 'off',
-    '@typescript-eslint/no-empty-object-type': 'off',
-    '@typescript-eslint/ban-ts-comment': 'off',
     '@typescript-eslint/no-unsafe-call': 'off',
-    '@typescript-eslint/no-unsafe-member-access': 'off',
-    '@typescript-eslint/no-unsafe-argument': 'off',
-    '@typescript-eslint/no-unsafe-assignment': 'off',
+    "@typescript-eslint/no-explicit-any": "off",
+    "@typescript-eslint/no-unsafe-return": "off",
   },
   languageOptions: {
     parser: tseslint.parser,

package-lock.json

@@ -89,15 +89,15 @@
     "puppeteer": "24.2.1",
     "regenerator-runtime": "0.14.1",
     "semantic-release": "24.2.3",
-    "typescript-eslint": "8.25.0",
+    "typescript-eslint": "8.26.0",
     "vinyl-source-stream": "2.0.0"
   },
   "optionalDependencies": {
     "crypto-js": "4.2.0"
   },
   "scripts": {
     "build": "node build_releases.js",
-    "build:types": "tsc && prettier --write 'types/{**/*,*}.ts'",
+    "build:types": "tsc",
     "ci:typecheck": "node ./ci/typecheck.js",
     "release": "node build_releases.js && npm publish",
     "test": "cross-env PARSE_BUILD=node jest",
@@ -106,11 +106,12 @@
     "posttest:mongodb": "mongodb-runner stop --all",
     "lint": "eslint --cache src/ integration/",
     "lint:fix": "eslint --fix --cache src/ integration/",
-    "test:types": "eslint --cache types/tests.ts -c eslint.config.test.mjs",
+    "test:types": "eslint types/tests.ts -c eslint.config.test.mjs",
     "watch": "cross-env PARSE_BUILD=${PARSE_BUILD} gulp watch",
     "watch:browser": "cross-env PARSE_BUILD=browser npm run watch",
     "watch:node": "cross-env PARSE_BUILD=node npm run watch",
     "watch:react-native": "cross-env PARSE_BUILD=react-native npm run watch",
+    "watch:ts": "tsc --watch",
     "integration": "cross-env TESTING=1 jasmine --config=jasmine.json",
     "docs": "jsdoc -c ./jsdoc-conf.json ./src",
     "madge:circular": "madge ./src --extensions js,ts --circular",

package.json

@@ -44,7 +44,7 @@ const AnonymousUtils = {
    *     linked to an anonymous user.
    * @static
    */
-  isLinked(user: ParseUser) {
+  isLinked(user: ParseUser): boolean {
     const provider = this._getAuthProvider();
     return user._isLinked(provider.getAuthType());
   },

src/AnonymousUtils.ts

@@ -37,7 +37,15 @@ import type { RequestOptions } from './RESTController';
  * @returns {Promise} A promise that will be resolved with the result
  * of the function.
  */
-export function run(name: string, data: any, options: RequestOptions): Promise<any> {
+export function run<T extends () => any>(
+  name: string,
+  data?: null,
+  options?: RequestOptions
+): Promise<ReturnType<T>>;
+export function run<
+  T extends (param: { [P in keyof Parameters<T>[0]]: Parameters<T>[0][P] }) => any,
+>(name: string, data: Parameters<T>[0], options?: RequestOptions): Promise<ReturnType<T>>;
+export function run(name: string, data?: any, options?: RequestOptions): Promise<any> {
   if (typeof name !== 'string' || name.length === 0) {
     throw new TypeError('Cloud function name must be a string.');
   }
@@ -88,7 +96,7 @@ export function getJobStatus(jobStatusId: string): Promise<ParseObject> {
 }
 
 const DefaultController = {
-  run(name: string, data: any, options: RequestOptions) {
+  run(name: string, data: any, options?: RequestOptions): Promise<any> {
     const RESTController = CoreManager.getRESTController();
     const payload = encode(data, true);
 
@@ -105,12 +113,12 @@ const DefaultController = {
     });
   },
 
-  getJobsData(options: RequestOptions) {
+  getJobsData(options?: RequestOptions): Promise<any> {
     const RESTController = CoreManager.getRESTController();
     return RESTController.request('GET', 'cloud_code/jobs/data', null, options);
   },
 
-  async startJob(name: string, data: any, options: RequestOptions) {
+  async startJob(name: string, data: any, options?: RequestOptions): Promise<string> {
     const RESTController = CoreManager.getRESTController();
 
     const payload = encode(data, true);

src/Cloud.ts

@@ -13,17 +13,16 @@ import type ParseSession from './ParseSession';
 import type { HookDeclaration, HookDeleteArg } from './ParseHooks';
 import type ParseConfig from './ParseConfig';
 import type LiveQueryClient from './LiveQueryClient';
-import type ParseSchema from './ParseSchema';
 import type ParseInstallation from './ParseInstallation';
 
 type AnalyticsController = {
   track: (name: string, dimensions: { [key: string]: string }) => Promise<any>;
 };
 type CloudController = {
-  run: (name: string, data: any, options: RequestOptions) => Promise<any>;
-  getJobsData: (options: RequestOptions) => Promise<any>;
+  run: (name: string, data: any, options?: RequestOptions) => Promise<any>;
+  getJobsData: (options?: RequestOptions) => Promise<any>;
   /** Returns promise which resolves with JobStatusId of the job */
-  startJob: (name: string, data: any, options: RequestOptions) => Promise<string>;
+  startJob: (name: string, data: any, options?: RequestOptions) => Promise<string>;
 };
 type ConfigController = {
   current: () => Promise<ParseConfig> | ParseConfig;
@@ -56,15 +55,15 @@ type ObjectController = {
   fetch: (
     object: ParseObject | Array<ParseObject>,
     forceFetch: boolean,
-    options: RequestOptions
+    options?: RequestOptions
   ) => Promise<Array<ParseObject | undefined> | ParseObject | undefined>;
   save: (
     object: ParseObject | Array<ParseObject | ParseFile> | null,
-    options: RequestOptions
+    options?: RequestOptions
   ) => Promise<ParseObject | Array<ParseObject> | ParseFile | undefined>;
   destroy: (
     object: ParseObject | Array<ParseObject>,
-    options: RequestOptions
+    options?: RequestOptions
   ) => Promise<ParseObject | Array<ParseObject>>;
 };
 type ObjectStateController = {
@@ -93,18 +92,52 @@ type QueryController = {
   find(
     className: string,
     params: QueryJSON,
-    options: RequestOptions
+    options?: RequestOptions
   ): Promise<{ results?: Array<ParseObject>; className?: string; count?: number }>;
   aggregate(
     className: string,
     params: any,
-    options: RequestOptions
+    options?: RequestOptions
   ): Promise<{ results?: Array<any> }>;
 };
-type EventuallyQueue = {
-  save: (object: ParseObject, serverOptions: SaveOptions) => Promise<any>;
-  destroy: (object: ParseObject, serverOptions: RequestOptions) => Promise<any>;
-  poll: (ms?: number) => void;
+export type QueueObject = {
+  queueId: string;
+  action: string;
+  object: ParseObject;
+  serverOptions: SaveOptions | RequestOptions;
+  id: string;
+  className: string;
+  hash: string;
+  createdAt: Date;
+};
+export type Queue = Array<QueueObject>;
+export type EventuallyQueue = {
+  save: (object: ParseObject, serverOptions?: SaveOptions) => Promise<void>;
+  destroy: (object: ParseObject, serverOptions?: RequestOptions) => Promise<void>;
+  generateQueueId: (action: string, object: ParseObject) => string;
+  enqueue(
+    action: string,
+    object: ParseObject,
+    serverOptions?: SaveOptions | RequestOptions
+  ): Promise<void>;
+  store(data: Queue): Promise<void>;
+  load(): Promise<string | null>;
+  getQueue(): Promise<Queue>;
+  setQueue(queue: Queue): Promise<void>;
+  remove(queueId: string): Promise<void>;
+  clear(): Promise<void>;
+  queueItemExists(queue: Queue, queueId: string): number;
+  length(): Promise<number>;
+  sendQueue(): Promise<boolean>;
+  sendQueueCallback(object: ParseObject, queueObject: QueueObject): Promise<void>;
+  poll(ms?: number): void;
+  stopPoll(): void;
+  isPolling(): boolean;
+  process: {
+    create(ObjectType: any, queueObject: any): Promise<void>;
+    byId(ObjectType: any, queueObject: any): Promise<void>;
+    byHash(ObjectType: any, queueObject: any): Promise<void>;
+  };
 };
 type RESTController = {
   request: (method: string, path: string, data?: any, options?: RequestOptions) => Promise<any>;
@@ -119,14 +152,14 @@ type RESTController = {
 };
 type SchemaController = {
   purge: (className: string) => Promise<any>;
-  get: (className: string, options?: RequestOptions) => Promise<{ results: ParseSchema[] }>;
+  get: (className: string, options?: RequestOptions) => Promise<any>;
   delete: (className: string, options?: RequestOptions) => Promise<void>;
   create: (className: string, params: any, options?: RequestOptions) => Promise<any>;
   update: (className: string, params: any, options?: RequestOptions) => Promise<any>;
-  send(className: string, method: string, params: any, options: RequestOptions): Promise<any>;
+  send(className: string, method: string, params: any, options?: RequestOptions): Promise<any>;
 };
 type SessionController = {
-  getSession: (token: RequestOptions) => Promise<ParseSession>;
+  getSession: (options?: RequestOptions) => Promise<ParseSession>;
 };
 type StorageController =
   | {
@@ -166,24 +199,24 @@ type UserController = {
   setCurrentUser: (user: ParseUser) => Promise<void>;
   currentUser: () => ParseUser | null;
   currentUserAsync: () => Promise<ParseUser | null>;
-  signUp: (user: ParseUser, attrs: AttributeMap, options: RequestOptions) => Promise<ParseUser>;
-  logIn: (user: ParseUser, options: RequestOptions) => Promise<ParseUser>;
+  signUp: (user: ParseUser, attrs: AttributeMap, options?: RequestOptions) => Promise<ParseUser>;
+  logIn: (user: ParseUser, options?: RequestOptions) => Promise<ParseUser>;
   loginAs: (user: ParseUser, userId: string) => Promise<ParseUser>;
-  become: (user: ParseUser, options: RequestOptions) => Promise<ParseUser>;
+  become: (user: ParseUser, options?: RequestOptions) => Promise<ParseUser>;
   hydrate: (user: ParseUser, userJSON: AttributeMap) => Promise<ParseUser>;
-  logOut: (options: RequestOptions) => Promise<void>;
-  me: (user: ParseUser, options: RequestOptions) => Promise<ParseUser>;
-  requestPasswordReset: (email: string, options: RequestOptions) => Promise<void>;
+  logOut: (options?: RequestOptions) => Promise<void>;
+  me: (user: ParseUser, options?: RequestOptions) => Promise<ParseUser>;
+  requestPasswordReset: (email: string, options?: RequestOptions) => Promise<void>;
   updateUserOnDisk: (user: ParseUser) => Promise<ParseUser>;
-  upgradeToRevocableSession: (user: ParseUser, options: RequestOptions) => Promise<void>;
+  upgradeToRevocableSession: (user: ParseUser, options?: RequestOptions) => Promise<void>;
   linkWith: (user: ParseUser, authData: AuthData, options?: FullOptions) => Promise<ParseUser>;
   removeUserFromDisk: () => Promise<ParseUser | void>;
   verifyPassword: (
     username: string,
     password: string,
-    options: RequestOptions
+    options?: RequestOptions
   ) => Promise<ParseUser>;
-  requestEmailVerification: (email: string, options: RequestOptions) => Promise<void>;
+  requestEmailVerification: (email: string, options?: RequestOptions) => Promise<void>;
 };
 type HooksController = {
   get: (type: string, functionName?: string, triggerName?: string) => Promise<any>;

src/CoreManager.ts

@@ -4,24 +4,12 @@ import ParseObject from './ParseObject';
 import ParseQuery from './ParseQuery';
 import Storage from './Storage';
 
+import type { Queue, QueueObject } from './CoreManager';
 import type { SaveOptions } from './ParseObject';
 import type { RequestOptions } from './RESTController';
 
-type QueueObject = {
-  queueId: string;
-  action: string;
-  object: ParseObject;
-  serverOptions: SaveOptions | RequestOptions;
-  id: string;
-  className: string;
-  hash: string;
-  createdAt: Date;
-};
-
-type Queue = Array<QueueObject>;
-
 const QUEUE_KEY = 'Parse/Eventually/Queue';
-let queueCache: QueueObject[] = [];
+let queueCache: Queue = [];
 let dirtyCache = true;
 let polling: ReturnType<typeof setInterval> | undefined = undefined;
 
@@ -44,7 +32,7 @@ const EventuallyQueue = {
    * @static
    * @see Parse.Object#saveEventually
    */
-  save(object: ParseObject, serverOptions: SaveOptions = {}): Promise<void> {
+  save(object: ParseObject, serverOptions?: SaveOptions): Promise<void> {
     return this.enqueue('save', object, serverOptions);
   },
 
@@ -59,7 +47,7 @@ const EventuallyQueue = {
    * @static
    * @see Parse.Object#destroyEventually
    */
-  destroy(object: ParseObject, serverOptions: RequestOptions = {}): Promise<void> {
+  destroy(object: ParseObject, serverOptions?: RequestOptions): Promise<void> {
     return this.enqueue('destroy', object, serverOptions);
   },
 
@@ -92,7 +80,7 @@ const EventuallyQueue = {
   async enqueue(
     action: string,
     object: ParseObject,
-    serverOptions: SaveOptions | RequestOptions
+    serverOptions?: SaveOptions | RequestOptions
   ): Promise<void> {
     const queueData = await this.getQueue();
     const queueId = this.generateQueueId(action, object);
@@ -112,7 +100,7 @@ const EventuallyQueue = {
       queueId,
       action,
       object: object.toJSON(),
-      serverOptions,
+      serverOptions: serverOptions || {},
       id: object.id,
       className: object.className,
       hash: object.get('hash'),
@@ -121,11 +109,11 @@ const EventuallyQueue = {
     return this.setQueue(queueData);
   },
 
-  store(data: QueueObject[]) {
+  store(data: Queue): Promise<void> {
     return Storage.setItemAsync(QUEUE_KEY, JSON.stringify(data));
   },
 
-  load() {
+  load(): Promise<string | null> {
     return Storage.getItemAsync(QUEUE_KEY);
   },
 
@@ -134,10 +122,10 @@ const EventuallyQueue = {
    *
    * @function getQueue
    * @name Parse.EventuallyQueue.getQueue
-   * @returns {Promise<QueueObject[]>}
+   * @returns {Promise<Queue>}
    * @static
    */
-  async getQueue(): Promise<QueueObject[]> {
+  async getQueue(): Promise<Queue> {
     if (dirtyCache) {
       queueCache = JSON.parse((await this.load()) || '[]');
       dirtyCache = false;
@@ -297,7 +285,7 @@ const EventuallyQueue = {
    * @param [ms] Milliseconds to ping the server. Default 2000ms
    * @static
    */
-  poll(ms = 2000) {
+  poll(ms?: number): void {
     if (polling) {
       return;
     }
@@ -311,7 +299,7 @@ const EventuallyQueue = {
           }
         })
         .catch(e => e);
-    }, ms);
+    }, ms || 2000);
   },
 
   /**
@@ -321,7 +309,7 @@ const EventuallyQueue = {
    * @name Parse.EventuallyQueue.stopPoll
    * @static
    */
-  stopPoll() {
+  stopPoll(): void {
     clearInterval(polling);
     polling = undefined;
   },

src/EventuallyQueue.ts

@@ -1,11 +1,11 @@
 /* global FB */
 import ParseUser from './ParseUser';
-import type { AuthProviderType } from './ParseUser';
+import type { AuthProvider } from './ParseUser';
 
 let initialized = false;
 let requestedPermissions;
 let initOptions;
-const provider: AuthProviderType = {
+const provider: AuthProvider = {
   authenticate(options) {
     if (typeof FB === 'undefined') {
       options.error(this, 'Facebook SDK not found.');
@@ -227,7 +227,7 @@ const FacebookUtils = {
   },
 
   // Used for testing purposes
-  _getAuthProvider() {
+  _getAuthProvider(): AuthProvider {
     return provider;
   },
 };