24 | * var dimensions = {
25 | * gender: 'm',
26 | * source: 'web',
27 | * dayType: 'weekend'
28 | * };
29 | * Parse.Analytics.track('signup', dimensions);
30 | *
31 | *
32 | * There is a default limit of 8 dimensions per event tracked.
33 | *
34 | * @function track
35 | * @name Parse.Analytics.track
36 | * @param {string} name The name of the custom event to report to Parse as
37 | * having happened.
38 | * @param {object} dimensions The dictionary of information by which to
39 | * segment this event.
40 | * @returns {Promise} A promise that is resolved when the round-trip
41 | * to the server completes.
42 | */
43 | export function track(name: string, dimensions: Recordtrue if the user has their account
44 | * linked to an anonymous user.
45 | * @static
46 | */
47 | isLinked(user: ParseUser): boolean {
48 | const provider = this._getAuthProvider();
49 | return user._isLinked(provider.getAuthType());
50 | },
51 |
52 | /**
53 | * Logs in a user Anonymously.
54 | *
55 | * @function logIn
56 | * @name Parse.AnonymousUtils.logIn
57 | * @param {object} options MasterKey / SessionToken.
58 | * @returns {Promise} Logged in user
59 | * @static
60 | */
61 | logIn(options?: RequestOptions): PromiseA Parse.Session object is a local representation of a revocable session. 11 | * This class is a subclass of a Parse.Object, and retains the same 12 | * functionality of a Parse.Object.
13 | * 14 | * @alias Parse.Session 15 | * @augments Parse.Object 16 | */ 17 | class ParseSessionleft & right
')).toBe('<p>left & right</p>'); 16 | }); 17 | }); 18 | -------------------------------------------------------------------------------- /src/__tests__/parseDate-test.js: -------------------------------------------------------------------------------- 1 | jest.autoMockOff(); 2 | 3 | const parseDate = require('../parseDate').default; 4 | 5 | describe('parseDate', () => { 6 | it('returns a Date for valid strings', () => { 7 | expect(Number(parseDate('2013-12-14T04:51:19.582Z'))).toBe( 8 | Number(new Date(Date.UTC(2013, 11, 14, 4, 51, 19, 582))) 9 | ); 10 | expect(Number(parseDate('2013-12-14T04:51:19Z'))).toBe( 11 | Number(new Date(Date.UTC(2013, 11, 14, 4, 51, 19))) 12 | ); 13 | }); 14 | 15 | it('returns null for invalid strings', () => { 16 | expect(parseDate('asdf')).toBe(null); 17 | }); 18 | }); 19 | -------------------------------------------------------------------------------- /src/__tests__/promiseUtils-test.js: -------------------------------------------------------------------------------- 1 | jest.autoMockOff(); 2 | 3 | const { when } = require('../promiseUtils'); 4 | 5 | describe('promiseUtils', () => { 6 | it('when', async () => { 7 | const promise1 = Promise.resolve(1); 8 | const promise2 = Promise.resolve(2); 9 | 10 | let result = await when([]); 11 | expect(result).toEqual([[]]); 12 | 13 | result = await when(promise1, promise2); 14 | expect(result).toEqual([1, 2]); 15 | 16 | result = await when(promise1, 'not a promise'); 17 | expect(result).toEqual([1, 'not a promise']); 18 | }); 19 | }); 20 | -------------------------------------------------------------------------------- /src/__tests__/react-native-test.js: -------------------------------------------------------------------------------- 1 | /* global WebSocket */ 2 | jest.dontMock('../CoreManager'); 3 | jest.dontMock('../CryptoController'); 4 | jest.dontMock('../decode'); 5 | jest.dontMock('../encode'); 6 | jest.dontMock('../EventEmitter'); 7 | jest.dontMock('../LiveQueryClient'); 8 | jest.dontMock('../LocalDatastore'); 9 | jest.dontMock('../ParseObject'); 10 | jest.dontMock('../Storage'); 11 | jest.dontMock('../LocalDatastoreController'); 12 | jest.dontMock('../WebSocketController'); 13 | jest.mock( 14 | 'react-native/Libraries/vendor/emitter/EventEmitter', 15 | () => { 16 | return { 17 | default: { 18 | prototype: { 19 | addListener: new (require('events').EventEmitter)(), 20 | }, 21 | }, 22 | }; 23 | }, 24 | { virtual: true } 25 | ); 26 | 27 | const mockEmitter = require('react-native/Libraries/vendor/emitter/EventEmitter').default; 28 | const CoreManager = require('../CoreManager').default; 29 | 30 | describe('React Native', () => { 31 | beforeEach(() => { 32 | process.env.PARSE_BUILD = 'react-native'; 33 | }); 34 | 35 | afterEach(() => { 36 | process.env.PARSE_BUILD = 'node'; 37 | }); 38 | 39 | it('load EventEmitter', () => { 40 | const EventEmitter = require('../EventEmitter').default; 41 | expect(EventEmitter).toEqual(mockEmitter); 42 | }); 43 | 44 | it('load CryptoController', () => { 45 | const CryptoJS = require('react-native-crypto-js'); 46 | jest.spyOn(CryptoJS.AES, 'encrypt').mockImplementation(() => { 47 | return { 48 | toString: () => 'World', 49 | }; 50 | }); 51 | const CryptoController = require('../CryptoController').default; 52 | const phrase = CryptoController.encrypt({}, 'salt'); 53 | expect(phrase).toBe('World'); 54 | expect(CryptoJS.AES.encrypt).toHaveBeenCalled(); 55 | }); 56 | 57 | it('load LocalDatastoreController', () => { 58 | const LocalDatastoreController = require('../LocalDatastoreController').default; 59 | require('../LocalDatastore'); 60 | const LDC = CoreManager.getLocalDatastoreController(); 61 | expect(LocalDatastoreController).toEqual(LDC); 62 | }); 63 | 64 | it('load StorageController', () => { 65 | const StorageController = require('../StorageController').default; 66 | CoreManager.setStorageController(StorageController); 67 | 68 | jest.spyOn(StorageController, 'setItemAsync'); 69 | const storage = require('../Storage').default; 70 | storage.setItemAsync('key', 'value'); 71 | expect(StorageController.setItemAsync).toHaveBeenCalledTimes(1); 72 | }); 73 | 74 | it('load WebSocketController', () => { 75 | const WebSocketController = require('../WebSocketController').default; 76 | CoreManager.setWebSocketController(WebSocketController); 77 | 78 | jest.mock('../EventEmitter', () => { 79 | return require('events').EventEmitter; 80 | }); 81 | const socket = WebSocket; 82 | require('../LiveQueryClient'); 83 | const websocket = CoreManager.getWebSocketController(); 84 | expect(websocket).toEqual(socket); 85 | }); 86 | }); 87 | -------------------------------------------------------------------------------- /src/__tests__/test_helpers/asyncHelper.js: -------------------------------------------------------------------------------- 1 | /* global runs waitsFor */ 2 | // We need this until Jest finishes upgrading to Jasmine 2.0 3 | module.exports = function asyncHelper(fn) { 4 | let finished = false; 5 | const done = function () { 6 | finished = true; 7 | }; 8 | 9 | return function () { 10 | runs(function () { 11 | fn(done); 12 | }); 13 | 14 | waitsFor(function () { 15 | return finished; 16 | }); 17 | }; 18 | }; 19 | -------------------------------------------------------------------------------- /src/__tests__/test_helpers/flushPromises.js: -------------------------------------------------------------------------------- 1 | const { setImmediate } = require('timers'); 2 | /** 3 | * Wait for all asynchronous code to finish executing 4 | */ 5 | function flushPromises() { 6 | return new Promise(resolve => setImmediate(resolve)); 7 | } 8 | 9 | module.exports = flushPromises; 10 | -------------------------------------------------------------------------------- /src/__tests__/test_helpers/mockAsyncStorage.js: -------------------------------------------------------------------------------- 1 | let mockStorage = {}; 2 | const mockAsyncStorage = { 3 | async: 1, 4 | async getItemAsync(path) { 5 | return mockStorage[path]; 6 | }, 7 | 8 | async setItemAsync(path, value) { 9 | mockStorage[path] = value; 10 | }, 11 | 12 | async removeItemAsync(path) { 13 | delete mockStorage[path]; 14 | }, 15 | 16 | async getAllKeysAsync() { 17 | return Object.keys(mockStorage); 18 | }, 19 | 20 | clear() { 21 | mockStorage = {}; 22 | }, 23 | }; 24 | 25 | module.exports = mockAsyncStorage; 26 | -------------------------------------------------------------------------------- /src/__tests__/test_helpers/mockFetch.js: -------------------------------------------------------------------------------- 1 | const { TextEncoder } = require('util'); 2 | /** 3 | * Mock fetch by pre-defining the statuses and results that it 4 | * return. 5 | * `results` is an array of objects of the form: 6 | * { status: ..., response: ... } 7 | * where status is a HTTP status number and result is a JSON object to pass 8 | * alongside it. 9 | * `upload`. 10 | * @ignore 11 | */ 12 | function mockFetch(results, headers = {}, error) { 13 | let attempts = -1; 14 | let didRead = false; 15 | global.fetch = jest.fn(async () => { 16 | attempts++; 17 | if (error) { 18 | return Promise.reject(error); 19 | } 20 | return Promise.resolve({ 21 | status: results[attempts].status, 22 | json: () => { 23 | const { response } = results[attempts]; 24 | return Promise.resolve(response); 25 | }, 26 | headers: { 27 | get: header => headers[header], 28 | has: header => headers[header] !== undefined, 29 | }, 30 | body: { 31 | getReader: () => ({ 32 | read: () => { 33 | if (didRead) { 34 | return Promise.resolve({ done: true }); 35 | } 36 | let { response } = results[attempts]; 37 | if (typeof response !== 'string') { 38 | response = JSON.stringify(response); 39 | } 40 | didRead = true; 41 | return Promise.resolve({ 42 | done: false, 43 | value: new TextEncoder().encode(response), 44 | }); 45 | }, 46 | }), 47 | }, 48 | }); 49 | }); 50 | } 51 | 52 | module.exports = mockFetch; 53 | -------------------------------------------------------------------------------- /src/__tests__/test_helpers/mockIndexedDB.js: -------------------------------------------------------------------------------- 1 | let mockStorage = {}; 2 | const mockStorageInterface = { 3 | createStore() {}, 4 | 5 | async get(path) { 6 | return mockStorage[path] || null; 7 | }, 8 | 9 | async set(path, value) { 10 | mockStorage[path] = value; 11 | }, 12 | 13 | async del(path) { 14 | delete mockStorage[path]; 15 | }, 16 | 17 | async keys() { 18 | return Object.keys(mockStorage); 19 | }, 20 | 21 | async clear() { 22 | mockStorage = {}; 23 | }, 24 | }; 25 | 26 | module.exports = mockStorageInterface; 27 | -------------------------------------------------------------------------------- /src/__tests__/test_helpers/mockRNStorage.js: -------------------------------------------------------------------------------- 1 | let mockStorage = {}; 2 | const mockRNStorage = { 3 | getItem(path, cb) { 4 | cb(undefined, mockStorage[path] || null); 5 | }, 6 | 7 | setItem(path, value, cb) { 8 | mockStorage[path] = value; 9 | cb(); 10 | }, 11 | 12 | removeItem(path, cb) { 13 | delete mockStorage[path]; 14 | cb(); 15 | }, 16 | 17 | getAllKeys(cb) { 18 | cb(undefined, Object.keys(mockStorage)); 19 | }, 20 | 21 | multiGet(keys, cb) { 22 | const objects = keys.map(key => [key, mockStorage[key]]); 23 | cb(undefined, objects); 24 | }, 25 | 26 | multiRemove(keys, cb) { 27 | keys.map(key => delete mockStorage[key]); 28 | cb(undefined); 29 | }, 30 | 31 | clear() { 32 | mockStorage = {}; 33 | }, 34 | }; 35 | 36 | module.exports = mockRNStorage; 37 | -------------------------------------------------------------------------------- /src/__tests__/test_helpers/mockWeChat.js: -------------------------------------------------------------------------------- 1 | let mockStorage = {}; 2 | let progressCallback = () => {}; 3 | let socketOpenCallback = () => {}; 4 | let socketMessageCallback = () => {}; 5 | let socketCloseCallback = () => {}; 6 | let SocketErrorCallback = () => {}; 7 | 8 | const mockWeChat = { 9 | getStorageSync(path) { 10 | return mockStorage[path]; 11 | }, 12 | 13 | setStorageSync(path, value) { 14 | mockStorage[path] = value; 15 | }, 16 | 17 | removeStorageSync(path) { 18 | delete mockStorage[path]; 19 | }, 20 | 21 | getStorageInfoSync() { 22 | return { 23 | keys: Object.keys(mockStorage), 24 | }; 25 | }, 26 | 27 | clearStorageSync() { 28 | mockStorage = {}; 29 | }, 30 | 31 | request(options) { 32 | return { 33 | onProgressUpdate: cb => { 34 | progressCallback = cb; 35 | }, 36 | abort: () => { 37 | progressCallback({ 38 | totalBytesExpectedToWrite: 0, 39 | totalBytesWritten: 0, 40 | }); 41 | options.success({ 42 | statusCode: 0, 43 | data: {}, 44 | }); 45 | options.fail(); 46 | }, 47 | }; 48 | }, 49 | 50 | connectSocket() {}, 51 | 52 | onSocketOpen(cb) { 53 | socketOpenCallback = cb; 54 | }, 55 | 56 | onSocketMessage(cb) { 57 | socketMessageCallback = cb; 58 | }, 59 | 60 | onSocketClose(cb) { 61 | socketCloseCallback = cb; 62 | }, 63 | 64 | onSocketError(cb) { 65 | SocketErrorCallback = cb; 66 | }, 67 | 68 | sendSocketMessage(data) { 69 | socketOpenCallback(); 70 | socketMessageCallback(data); 71 | }, 72 | 73 | closeSocket() { 74 | socketCloseCallback(); 75 | SocketErrorCallback(); 76 | }, 77 | }; 78 | 79 | module.exports = mockWeChat; 80 | -------------------------------------------------------------------------------- /src/__tests__/unique-test.js: -------------------------------------------------------------------------------- 1 | jest.dontMock('../arrayContainsObject'); 2 | jest.dontMock('../unique'); 3 | 4 | let localCount = 0; 5 | const mockObject = function (className, id) { 6 | this.className = className; 7 | this.id = id; 8 | if (!id) { 9 | this._localId = 'local' + localCount++; 10 | } 11 | }; 12 | mockObject.prototype._getId = function () { 13 | return this.id || this._localId; 14 | }; 15 | jest.setMock('../ParseObject', { 16 | __esModule: true, 17 | default: mockObject, 18 | }); 19 | 20 | const unique = require('../unique').default; 21 | const ParseObject = require('../ParseObject').default; 22 | const CoreManager = require('../CoreManager').default; 23 | jest 24 | .spyOn(CoreManager, 'getParseObject') 25 | .mockImplementation(() => require('../ParseObject').default); 26 | 27 | describe('unique', () => { 28 | it('produces an array with unique elements', () => { 29 | expect(unique([])).toEqual([]); 30 | expect(unique([1])).toEqual([1]); 31 | expect(unique([3, 4, 1])).toEqual([3, 4, 1]); 32 | expect(unique([3, 4, 3, 1])).toEqual([3, 4, 1]); 33 | expect(unique([2, 2, 2, 2, 2, 2, 2])).toEqual([2]); 34 | expect(unique(['a', 'b', 'c', 'a', 'd'])).toEqual(['a', 'b', 'c', 'd']); 35 | }); 36 | 37 | it('dedups objects by their id', () => { 38 | const o = new ParseObject('Item'); 39 | expect(unique([o, o, o])).toEqual([o]); 40 | expect(unique([new ParseObject('Item'), new ParseObject('Item')]).length).toBe(2); 41 | expect( 42 | unique([ 43 | new ParseObject('Item', 'a'), 44 | new ParseObject('Item', 'b'), 45 | new ParseObject('Item', 'a'), 46 | ]) 47 | ).toEqual([new ParseObject('Item', 'a'), new ParseObject('Item', 'b')]); 48 | expect( 49 | unique([ 50 | new ParseObject('Item', 'a'), 51 | new ParseObject('Item', 'b'), 52 | new ParseObject('Item', 'b'), 53 | new ParseObject('Item', 'a'), 54 | ]) 55 | ).toEqual([new ParseObject('Item', 'a'), new ParseObject('Item', 'b')]); 56 | }); 57 | }); 58 | -------------------------------------------------------------------------------- /src/__tests__/weapp-test.js: -------------------------------------------------------------------------------- 1 | jest.dontMock('../CoreManager'); 2 | jest.dontMock('../CryptoController'); 3 | jest.dontMock('../decode'); 4 | jest.dontMock('../encode'); 5 | jest.dontMock('../EventEmitter'); 6 | jest.dontMock('../LiveQueryClient'); 7 | jest.dontMock('../Parse'); 8 | jest.dontMock('../ParseFile'); 9 | jest.dontMock('../ParseObject'); 10 | jest.dontMock('../RESTController'); 11 | jest.dontMock('../Socket.weapp'); 12 | jest.dontMock('../Storage'); 13 | jest.dontMock('../StorageController.weapp'); 14 | jest.dontMock('../uuid'); 15 | jest.dontMock('crypto-js/aes'); 16 | jest.dontMock('./test_helpers/mockWeChat'); 17 | 18 | const CoreManager = require('../CoreManager').default; 19 | const mockWeChat = require('./test_helpers/mockWeChat'); 20 | 21 | global.wx = mockWeChat; 22 | 23 | jest.mock('uuid', () => { 24 | return () => 0; 25 | }); 26 | 27 | describe('WeChat', () => { 28 | beforeEach(() => { 29 | process.env.PARSE_BUILD = 'weapp'; 30 | }); 31 | 32 | afterEach(() => { 33 | process.env.PARSE_BUILD = 'node'; 34 | }); 35 | 36 | it('load StorageController', () => { 37 | const StorageController = require('../StorageController').default; 38 | CoreManager.setStorageController(StorageController); 39 | jest.spyOn(StorageController, 'setItem'); 40 | const storage = require('../Storage').default; 41 | storage.setItem('key', 'value'); 42 | expect(StorageController.setItem).toHaveBeenCalledTimes(1); 43 | }); 44 | 45 | it('load RESTController', () => { 46 | const XHR = require('../Xhr.weapp'); 47 | jest.spyOn(XHR, 'polyfillFetch'); 48 | const RESTController = require('../RESTController').default; 49 | expect(XHR.polyfillFetch).toHaveBeenCalled(); 50 | expect(RESTController).toBeDefined(); 51 | }); 52 | 53 | it('load WebSocketController', () => { 54 | const socket = require('../WebSocketController'); 55 | CoreManager.setWebSocketController(socket); 56 | 57 | require('../LiveQueryClient'); 58 | const websocket = CoreManager.getWebSocketController(); 59 | expect(websocket).toEqual(socket); 60 | }); 61 | 62 | it('load uuid module', () => { 63 | const uuidv4 = require('../uuid').default; 64 | expect(uuidv4()).not.toEqual(0); 65 | expect(uuidv4()).not.toEqual(uuidv4()); 66 | }); 67 | 68 | describe('Socket', () => { 69 | it('send', () => { 70 | const Websocket = require('../Socket.weapp').default; 71 | jest.spyOn(mockWeChat, 'connectSocket'); 72 | const socket = new Websocket('wss://examples.com'); 73 | socket.onopen(); 74 | socket.onmessage(); 75 | socket.onclose(); 76 | socket.onerror(); 77 | socket.onopen = jest.fn(); 78 | socket.onmessage = jest.fn(); 79 | socket.onclose = jest.fn(); 80 | socket.onerror = jest.fn(); 81 | 82 | expect(mockWeChat.connectSocket).toHaveBeenCalled(); 83 | 84 | socket.send('{}'); 85 | expect(socket.onopen).toHaveBeenCalled(); 86 | expect(socket.onmessage).toHaveBeenCalled(); 87 | 88 | socket.close(); 89 | expect(socket.onclose).toHaveBeenCalled(); 90 | expect(socket.onerror).toHaveBeenCalled(); 91 | }); 92 | }); 93 | }); 94 | -------------------------------------------------------------------------------- /src/arrayContainsObject.ts: -------------------------------------------------------------------------------- 1 | import CoreManager from './CoreManager'; 2 | import type ParseObject from './ParseObject'; 3 | 4 | export default function arrayContainsObject(array: any[], object: ParseObject): boolean { 5 | if (array.indexOf(object) > -1) { 6 | return true; 7 | } 8 | const ParseObject = CoreManager.getParseObject(); 9 | for (let i = 0; i < array.length; i++) { 10 | if ( 11 | array[i] instanceof ParseObject && 12 | array[i].className === object.className && 13 | array[i]._getId() === object._getId() 14 | ) { 15 | return true; 16 | } 17 | } 18 | return false; 19 | } 20 | -------------------------------------------------------------------------------- /src/canBeSerialized.ts: -------------------------------------------------------------------------------- 1 | import CoreManager from './CoreManager'; 2 | import ParseFile from './ParseFile'; 3 | import type ParseObject from './ParseObject'; 4 | import ParseRelation from './ParseRelation'; 5 | 6 | export default function canBeSerialized(obj: ParseObject): boolean { 7 | const ParseObject = CoreManager.getParseObject(); 8 | if (!(obj instanceof ParseObject)) { 9 | return true; 10 | } 11 | const attributes = obj.attributes; 12 | for (const attr in attributes) { 13 | const val = attributes[attr]; 14 | if (!canBeSerializedHelper(val)) { 15 | return false; 16 | } 17 | } 18 | return true; 19 | } 20 | 21 | function canBeSerializedHelper(value: any): boolean { 22 | if (typeof value !== 'object') { 23 | return true; 24 | } 25 | if (value instanceof ParseRelation) { 26 | return true; 27 | } 28 | const ParseObject = CoreManager.getParseObject(); 29 | if (value instanceof ParseObject) { 30 | return !!value.id; 31 | } 32 | if (value instanceof ParseFile) { 33 | if (value.url()) { 34 | return true; 35 | } 36 | return false; 37 | } 38 | if (Array.isArray(value)) { 39 | for (let i = 0; i < value.length; i++) { 40 | if (!canBeSerializedHelper(value[i])) { 41 | return false; 42 | } 43 | } 44 | return true; 45 | } 46 | for (const k in value) { 47 | if (!canBeSerializedHelper(value[k])) { 48 | return false; 49 | } 50 | } 51 | return true; 52 | } 53 | -------------------------------------------------------------------------------- /src/decode.ts: -------------------------------------------------------------------------------- 1 | import CoreManager from './CoreManager'; 2 | import ParseFile from './ParseFile'; 3 | import ParseGeoPoint from './ParseGeoPoint'; 4 | import ParsePolygon from './ParsePolygon'; 5 | import ParseRelation from './ParseRelation'; 6 | 7 | export default function decode(value: any): any { 8 | if (value === null || typeof value !== 'object' || value instanceof Date) { 9 | return value; 10 | } 11 | if (Array.isArray(value)) { 12 | const dup = []; 13 | value.forEach((v, i) => { 14 | dup[i] = decode(v); 15 | }); 16 | return dup; 17 | } 18 | if (typeof value.__op === 'string') { 19 | const { opFromJSON } = CoreManager.getParseOp(); 20 | return opFromJSON(value); 21 | } 22 | const ParseObject = CoreManager.getParseObject(); 23 | if (value.__type === 'Pointer' && value.className) { 24 | return ParseObject.fromJSON(value); 25 | } 26 | if (value.__type === 'Object' && value.className) { 27 | return ParseObject.fromJSON(value); 28 | } 29 | if (value.__type === 'Relation') { 30 | // The parent and key fields will be populated by the parent 31 | const relation = new ParseRelation(null, null); 32 | relation.targetClassName = value.className; 33 | return relation; 34 | } 35 | if (value.__type === 'Date') { 36 | return new Date(value.iso); 37 | } 38 | if (value.__type === 'File') { 39 | return ParseFile.fromJSON(value); 40 | } 41 | if (value.__type === 'GeoPoint') { 42 | return new ParseGeoPoint({ 43 | latitude: value.latitude, 44 | longitude: value.longitude, 45 | }); 46 | } 47 | if (value.__type === 'Polygon') { 48 | return new ParsePolygon(value.coordinates); 49 | } 50 | const copy = {}; 51 | for (const k in value) { 52 | copy[k] = decode(value[k]); 53 | } 54 | return copy; 55 | } 56 | -------------------------------------------------------------------------------- /src/encode.ts: -------------------------------------------------------------------------------- 1 | import CoreManager from './CoreManager'; 2 | import ParseACL from './ParseACL'; 3 | import ParseFile from './ParseFile'; 4 | import ParseGeoPoint from './ParseGeoPoint'; 5 | import ParsePolygon from './ParsePolygon'; 6 | import ParseRelation from './ParseRelation'; 7 | 8 | function encode( 9 | value: any, 10 | disallowObjects: boolean, 11 | forcePointers: boolean, 12 | seen: any[], 13 | offline: boolean 14 | ): any { 15 | const ParseObject = CoreManager.getParseObject(); 16 | if (value instanceof ParseObject) { 17 | if (disallowObjects) { 18 | throw new Error('Parse Objects not allowed here'); 19 | } 20 | const seenEntry = value.id ? value.className + ':' + value.id : value; 21 | if ( 22 | forcePointers || 23 | !seen || 24 | seen.indexOf(seenEntry) > -1 || 25 | value.dirty() || 26 | Object.keys(value._getServerData()).length < 1 27 | ) { 28 | if (offline && value._getId().startsWith('local')) { 29 | return value.toOfflinePointer(); 30 | } 31 | return value.toPointer(); 32 | } 33 | seen = seen.concat(seenEntry); 34 | return value._toFullJSON(seen, offline); 35 | } 36 | const { Op } = CoreManager.getParseOp(); 37 | if ( 38 | value instanceof Op || 39 | value instanceof ParseACL || 40 | value instanceof ParseGeoPoint || 41 | value instanceof ParsePolygon || 42 | value instanceof ParseRelation 43 | ) { 44 | return value.toJSON(); 45 | } 46 | if (value instanceof ParseFile) { 47 | if (!value.url()) { 48 | throw new Error('Tried to encode an unsaved file.'); 49 | } 50 | return value.toJSON(); 51 | } 52 | if (Object.prototype.toString.call(value) === '[object Date]') { 53 | if (isNaN(value)) { 54 | throw new Error('Tried to encode an invalid date.'); 55 | } 56 | return { __type: 'Date', iso: (value as Date).toJSON() }; 57 | } 58 | if ( 59 | Object.prototype.toString.call(value) === '[object RegExp]' && 60 | typeof value.source === 'string' 61 | ) { 62 | return value.source; 63 | } 64 | 65 | if (Array.isArray(value)) { 66 | return value.map(v => { 67 | return encode(v, disallowObjects, forcePointers, seen, offline); 68 | }); 69 | } 70 | 71 | if (value && typeof value === 'object') { 72 | const output = {}; 73 | for (const k in value) { 74 | output[k] = encode(value[k], disallowObjects, forcePointers, seen, offline); 75 | } 76 | return output; 77 | } 78 | 79 | return value; 80 | } 81 | 82 | export default function ( 83 | value: any, 84 | disallowObjects?: boolean, 85 | forcePointers?: boolean, 86 | seen?: any[], 87 | offline?: boolean 88 | ): any { 89 | return encode(value, !!disallowObjects, !!forcePointers, seen || [], offline); 90 | } 91 | -------------------------------------------------------------------------------- /src/equals.ts: -------------------------------------------------------------------------------- 1 | import CoreManager from './CoreManager'; 2 | import ParseACL from './ParseACL'; 3 | import ParseFile from './ParseFile'; 4 | import ParseGeoPoint from './ParseGeoPoint'; 5 | 6 | export default function equals(a: any, b: any): boolean { 7 | const toString = Object.prototype.toString; 8 | if (toString.call(a) === '[object Date]' || toString.call(b) === '[object Date]') { 9 | const dateA = new Date(a); 10 | const dateB = new Date(b); 11 | return +dateA === +dateB; 12 | } 13 | 14 | if (typeof a !== typeof b) { 15 | return false; 16 | } 17 | 18 | if (!a || typeof a !== 'object') { 19 | // a is a primitive 20 | return a === b; 21 | } 22 | 23 | if (Array.isArray(a) || Array.isArray(b)) { 24 | if (!Array.isArray(a) || !Array.isArray(b)) { 25 | return false; 26 | } 27 | if (a.length !== b.length) { 28 | return false; 29 | } 30 | for (let i = 0; i < a.length; i += 1) { 31 | if (!equals(a[i], b[i])) { 32 | return false; 33 | } 34 | } 35 | return true; 36 | } 37 | const ParseObject = CoreManager.getParseObject(); 38 | if ( 39 | a instanceof ParseACL || 40 | a instanceof ParseFile || 41 | a instanceof ParseGeoPoint || 42 | a instanceof ParseObject 43 | ) { 44 | return a.equals(b); 45 | } 46 | if (b instanceof ParseObject) { 47 | if (a.__type === 'Object' || a.__type === 'Pointer') { 48 | return a.objectId === b.id && a.className === b.className; 49 | } 50 | } 51 | if (Object.keys(a).length !== Object.keys(b).length) { 52 | return false; 53 | } 54 | for (const k in a) { 55 | if (!equals(a[k], b[k])) { 56 | return false; 57 | } 58 | } 59 | return true; 60 | } 61 | -------------------------------------------------------------------------------- /src/escape.ts: -------------------------------------------------------------------------------- 1 | const encoded = { 2 | '&': '&', 3 | '<': '<', 4 | '>': '>', 5 | '/': '/', 6 | "'": ''', 7 | '"': '"', 8 | }; 9 | 10 | export default function escape(str: string): string { 11 | return str.replace(/[&<>\/'"]/g, function (char) { 12 | return encoded[char]; 13 | }); 14 | } 15 | -------------------------------------------------------------------------------- /src/interfaces/AuthProvider.ts: -------------------------------------------------------------------------------- 1 | /* eslint-disable @typescript-eslint/no-unused-vars */ 2 | /** 3 | * Interface declaration for Authentication Providers 4 | * 5 | * @interface AuthProvider 6 | */ 7 | export class AuthProvider { 8 | /** 9 | * Called when _linkWith isn't passed authData. 10 | * Handle your own authentication here. 11 | * 12 | * @param {object} options options.success(provider, authData) or options.error(provider, error) on completion 13 | */ 14 | authenticate(options: any): void {} 15 | 16 | /** 17 | * (Optional) Called when service is unlinked. 18 | * Handle any cleanup here. 19 | */ 20 | deauthenticate(): void {} 21 | 22 | /** 23 | * Unique identifier for this Auth Provider. 24 | * 25 | * @returns {string} identifier 26 | */ 27 | getAuthType(): string {} 28 | 29 | /** 30 | * Called when auth data is syncronized. 31 | * Can be used to determine if authData is still valid 32 | * 33 | * @param {object} authData Data used when register provider 34 | * @returns {boolean} Indicate if service should continue to be linked 35 | */ 36 | restoreAuthentication(authData: any): boolean {} 37 | } 38 | -------------------------------------------------------------------------------- /src/interfaces/react-native.ts: -------------------------------------------------------------------------------- 1 | /** 2 | * Interface declaration for React Native modules 3 | */ 4 | declare module 'react-native' { 5 | declare class AsyncStorage { 6 | static getItem(path: string, cb: (err: string, value: string) => void): void; 7 | static setItem(path: string, value: string, cb: (err: string, value: string) => void): void; 8 | static removeItem(path: string, cb: (err: string, value: string) => void): void; 9 | static getAllKeys(cb: (err: string, keys: string[]) => void): void; 10 | static clear(): void; 11 | } 12 | } 13 | -------------------------------------------------------------------------------- /src/interfaces/xmlhttprequest.ts: -------------------------------------------------------------------------------- 1 | /* eslint-disable */ 2 | declare module xmlhttprequest { 3 | declare var XMLHttpRequest: () => XMLHttpRequest; 4 | } 5 | -------------------------------------------------------------------------------- /src/isRevocableSession.ts: -------------------------------------------------------------------------------- 1 | export default function isRevocableSession(token: string): boolean { 2 | return token.indexOf('r:') > -1; 3 | } 4 | -------------------------------------------------------------------------------- /src/parseDate.ts: -------------------------------------------------------------------------------- 1 | export default function parseDate(iso8601: string): Date | null { 2 | const regexp = new RegExp( 3 | '^([0-9]{1,4})-([0-9]{1,2})-([0-9]{1,2})' + 4 | 'T' + 5 | '([0-9]{1,2}):([0-9]{1,2}):([0-9]{1,2})' + 6 | '(.([0-9]+))?' + 7 | 'Z$' 8 | ); 9 | const match = regexp.exec(iso8601); 10 | if (!match) { 11 | return null; 12 | } 13 | 14 | const year = parseInt(match[1]) || 0; 15 | const month = (parseInt(match[2]) || 1) - 1; 16 | const day = parseInt(match[3]) || 0; 17 | const hour = parseInt(match[4]) || 0; 18 | const minute = parseInt(match[5]) || 0; 19 | const second = parseInt(match[6]) || 0; 20 | const milli = parseInt(match[8]) || 0; 21 | 22 | return new Date(Date.UTC(year, month, day, hour, minute, second, milli)); 23 | } 24 | -------------------------------------------------------------------------------- /src/promiseUtils.ts: -------------------------------------------------------------------------------- 1 | // Create Deferred Promise 2 | export function resolvingPromise
21 | * var dimensions = {
22 | * gender: 'm',
23 | * source: 'web',
24 | * dayType: 'weekend'
25 | * };
26 | * Parse.Analytics.track('signup', dimensions);
27 | *
28 | *
29 | * There is a default limit of 8 dimensions per event tracked.
30 | *
31 | * @function track
32 | * @name Parse.Analytics.track
33 | * @param {string} name The name of the custom event to report to Parse as
34 | * having happened.
35 | * @param {object} dimensions The dictionary of information by which to
36 | * segment this event.
37 | * @returns {Promise} A promise that is resolved when the round-trip
38 | * to the server completes.
39 | */
40 | export declare function track(name: string, dimensions: Recordtrue if the user has their account
40 | * linked to an anonymous user.
41 | * @static
42 | */
43 | isLinked(user: ParseUser): boolean;
44 | /**
45 | * Logs in a user Anonymously.
46 | *
47 | * @function logIn
48 | * @name Parse.AnonymousUtils.logIn
49 | * @param {object} options MasterKey / SessionToken.
50 | * @returns {Promise} Logged in user
51 | * @static
52 | */
53 | logIn(options?: RequestOptions): Promise7 | * Some functions are only available from Cloud Code. 8 | *
9 | * 10 | * @class Parse.Cloud 11 | * @static 12 | * @hideconstructor 13 | */ 14 | /** 15 | * Makes a call to a cloud function. 16 | * 17 | * @function run 18 | * @name Parse.Cloud.run 19 | * @param {string} name The function name. 20 | * @param {object} data The parameters to send to the cloud function. 21 | * @param {object} options 22 | * Valid options are:Response Object - Contains data from the client that made the request 8 | *
Open Event - When you call query.subscribe(), we send a subscribe request to 15 | * the LiveQuery server, when we get the confirmation from the LiveQuery server, 16 | * this event will be emitted. When the client loses WebSocket connection to the 17 | * LiveQuery server, we will try to auto reconnect the LiveQuery server. If we 18 | * reconnect the LiveQuery server and successfully resubscribe the ParseQuery, 19 | * you'll also get this event. 20 | * 21 | *
22 | * subscription.on('open', (response) => {
23 | *
24 | * });
25 | *
26 | * Create Event - When a new ParseObject is created and it fulfills the ParseQuery you subscribe, 27 | * you'll get this event. The object is the ParseObject which is created. 28 | * 29 | *
30 | * subscription.on('create', (object, response) => {
31 | *
32 | * });
33 | *
34 | * Update Event - When an existing ParseObject (original) which fulfills the ParseQuery you subscribe 35 | * is updated (The ParseObject fulfills the ParseQuery before and after changes), 36 | * you'll get this event. The object is the ParseObject which is updated. 37 | * Its content is the latest value of the ParseObject. 38 | * 39 | * Parse-Server 3.1.3+ Required for original object parameter 40 | * 41 | *
42 | * subscription.on('update', (object, original, response) => {
43 | *
44 | * });
45 | *
46 | * Enter Event - When an existing ParseObject's (original) old value doesn't fulfill the ParseQuery 47 | * but its new value fulfills the ParseQuery, you'll get this event. The object is the 48 | * ParseObject which enters the ParseQuery. Its content is the latest value of the ParseObject. 49 | * 50 | * Parse-Server 3.1.3+ Required for original object parameter 51 | * 52 | *
53 | * subscription.on('enter', (object, original, response) => {
54 | *
55 | * });
56 | *
57 | *
58 | * Update Event - When an existing ParseObject's old value fulfills the ParseQuery but its new value 59 | * doesn't fulfill the ParseQuery, you'll get this event. The object is the ParseObject 60 | * which leaves the ParseQuery. Its content is the latest value of the ParseObject. 61 | * 62 | *
63 | * subscription.on('leave', (object, response) => {
64 | *
65 | * });
66 | *
67 | *
68 | * Delete Event - When an existing ParseObject which fulfills the ParseQuery is deleted, you'll 69 | * get this event. The object is the ParseObject which is deleted. 70 | * 71 | *
72 | * subscription.on('delete', (object, response) => {
73 | *
74 | * });
75 | *
76 | *
77 | * Close Event - When the client loses the WebSocket connection to the LiveQuery 78 | * server and we stop receiving events, you'll get this event. 79 | * 80 | *
81 | * subscription.on('close', () => {
82 | *
83 | * });
84 | */
85 | declare class LiveQuerySubscription {
86 | id: string | number;
87 | query: ParseQuery;
88 | sessionToken?: string;
89 | subscribePromise: any;
90 | unsubscribePromise: any;
91 | subscribed: boolean;
92 | emitter: EventEmitter;
93 | on: EventEmitter['on'];
94 | emit: EventEmitter['emit'];
95 | constructor(id: string | number, query: ParseQuery, sessionToken?: string);
96 | /**
97 | * Close the subscription
98 | *
99 | * @returns {Promise}
100 | */
101 | unsubscribe(): PromiseParse.Object. Parse.enableLocalDatastore().
5 | *
6 | * Pin object to add to local datastore
7 | *
8 | * await object.pin();9 | *
await object.pinWithName('pinName');
10 | *
11 | * Query pinned objects
12 | *
13 | * query.fromLocalDatastore();14 | *
query.fromPin();15 | *
query.fromPinWithName();16 | * 17 | *
const localObjects = await query.find();18 | * 19 | * @class Parse.LocalDatastore 20 | * @static 21 | */ 22 | declare const LocalDatastore: { 23 | isEnabled: boolean; 24 | isSyncing: boolean; 25 | fromPinWithName(name: string): Promise
44 | * await Parse.LocalDatastore.updateFromServer(); 45 | *46 | * 47 | * @function updateFromServer 48 | * @name Parse.LocalDatastore.updateFromServer 49 | * @static 50 | */ 51 | updateFromServer(): Promise
Open - When we establish the WebSocket connection to the LiveQuery server, you'll get this event. 6 | * 7 | *
8 | * Parse.LiveQuery.on('open', () => {
9 | *
10 | * });
11 | *
12 | * Close - When we lose the WebSocket connection to the LiveQuery server, you'll get this event. 13 | * 14 | *
15 | * Parse.LiveQuery.on('close', () => {
16 | *
17 | * });
18 | *
19 | * Error - When some network error or LiveQuery server error happens, you'll get this event. 20 | * 21 | *
22 | * Parse.LiveQuery.on('error', (error) => {
23 | *
24 | * });
25 | *
26 | * @class Parse.LiveQuery
27 | * @static
28 | */
29 | declare class LiveQuery {
30 | emitter: EventEmitter;
31 | on: EventEmitter['on'];
32 | emit: EventEmitter['emit'];
33 | constructor();
34 | /**
35 | * After open is called, the LiveQuery will try to send a connect request
36 | * to the LiveQuery server.
37 | */
38 | open(): Promise7 | * new Polygon([[0,0],[0,1],[1,1],[1,0]]) 8 | * new Polygon([GeoPoint, GeoPoint, GeoPoint]) 9 | *10 | * 11 | *
Represents a coordinates that may be associated 12 | * with a key in a ParseObject or used as a reference point for geo queries. 13 | * This allows proximity-based queries on the key.
14 | * 15 | *Example:
16 | * var polygon = new Parse.Polygon([[0,0],[0,1],[1,1],[1,0]]);
17 | * var object = new Parse.Object("PlaceObject");
18 | * object.set("area", polygon);
19 | * object.save();
20 | *
21 | * @alias Parse.Polygon
22 | */
23 | declare class ParsePolygon {
24 | _coordinates: Coordinates;
25 | /**
26 | * @param {(Coordinates | Parse.GeoPoint[])} coordinates An Array of coordinate pairs
27 | */
28 | constructor(coordinates: Coordinates | ParseGeoPoint[]);
29 | /**
30 | * Coordinates value for this Polygon.
31 | * Throws an exception if not valid type.
32 | *
33 | * @property {(Coordinates | Parse.GeoPoint[])} coordinates list of coordinates
34 | * @returns {Coordinates}
35 | */
36 | get coordinates(): Coordinates;
37 | set coordinates(coords: Coordinates | ParseGeoPoint[]);
38 | /**
39 | * Returns a JSON representation of the Polygon, suitable for Parse.
40 | *
41 | * @returns {object}
42 | */
43 | toJSON(): {
44 | __type: string;
45 | coordinates: Coordinates;
46 | };
47 | /**
48 | * Checks if two polygons are equal
49 | *
50 | * @param {(Parse.Polygon | object)} other
51 | * @returns {boolean}
52 | */
53 | equals(other: ParsePolygon | any): boolean;
54 | /**
55 | *
56 | * @param {Parse.GeoPoint} point
57 | * @returns {boolean} Returns if the point is contained in the polygon
58 | */
59 | containsPoint(point: ParseGeoPoint): boolean;
60 | /**
61 | * Validates that the list of coordinates can form a valid polygon
62 | *
63 | * @param {Array} coords the list of coordinates to validate as a polygon
64 | * @throws {TypeError}
65 | * @returns {number[][]} Array of coordinates if validated.
66 | */
67 | static _validate(coords: Coordinates | ParseGeoPoint[]): Coordinates;
68 | }
69 | export default ParsePolygon;
70 |
--------------------------------------------------------------------------------
/types/ParseRelation.d.ts:
--------------------------------------------------------------------------------
1 | import type ParseObject from './ParseObject';
2 | import type ParseQuery from './ParseQuery';
3 | /**
4 | * Creates a new Relation for the given parent object and key. This
5 | * constructor should rarely be used directly, but rather created by
6 | * Parse.Object.relation.
7 | *
8 | * 9 | * A class that is used to access all of the children of a many-to-many 10 | * relationship. Each instance of Parse.Relation is associated with a 11 | * particular parent object and key. 12 | *
13 | * 14 | * @alias Parse.Relation 15 | */ 16 | declare class ParseRelationRoles must have a name (which cannot be changed after creation of the 15 | * role), and must specify an ACL.
16 | * 17 | * @alias Parse.Role 18 | * @augments Parse.Object 19 | */ 20 | declare class ParseRole40 | * A role's name can only contain alphanumeric characters, _, -, and 41 | * spaces. 42 | *
43 | * 44 | *This is equivalent to calling role.set("name", name)
45 | * 46 | * @param {string} name The name of the role. 47 | * @param {object} options Standard options object with success and error 48 | * callbacks. 49 | * @returns {Parse.Object} Returns the object, so you can chain this call. 50 | */ 51 | setName(name: string, options?: SetOptions): this; 52 | /** 53 | * Gets the Parse.Relation for the Parse.Users that are direct 54 | * children of this role. These users are granted any privileges that this 55 | * role has been granted (e.g. read or write access through ACLs). You can 56 | * add or remove users from the role through this relation. 57 | * 58 | *This is equivalent to calling role.relation("users")
59 | * 60 | * @returns {Parse.Relation} the relation for the users belonging to this 61 | * role. 62 | */ 63 | getUsers(): ParseRelationThis is equivalent to calling role.relation("roles")
71 | * 72 | * @returns {Parse.Relation} the relation for the roles belonging to this 73 | * role. 74 | */ 75 | getRoles(): ParseRelationA Parse.Session object is a local representation of a revocable session. 5 | * This class is a subclass of a Parse.Object, and retains the same 6 | * functionality of a Parse.Object.
7 | * 8 | * @alias Parse.Session 9 | * @augments Parse.Object 10 | */ 11 | declare class ParseSession