adding ts and package.json typings (#1076)

* adding ts and package.json typings

* remove DefinitelyTyped needed comments, we are hosting this ourselves

* adding licensing comments

* Added initial contribution support

Thanks @akim95

* changing year

* adding parameters

* Expand on collection typings

* update the windows pre-gyp script (#1072)

* Extract admin status from the refresh token (#1078)

* Extract admin status from the refresh token

Fixes #1063

* wire up rpc

* Make sure all callbacks enqueue on the Node.js event loop (#1079)

Fixes #1077

* Use an uncached realm instance for _waitForDownload (#1083)

Fixes #1061

* Add objectSchema method to Realm Object (#1055)

* Add objectSchema property to Realm Object

* fix

* fixes

* move typings under lib/

* changelog

CHANGELOG.md

@@ -4,7 +4,7 @@ vNext Release notes (TBD)
 * None
 
 ### Enhancements
-* None
+* Added bundled TypeScript declarations of the Realm API.
 
 ### Bug fixes
 * Fix `Realm.Sync.User.prototype.isAdmin` returning `false` for logged-in admin users. 

lib/collection-methods.js

@@ -31,14 +31,20 @@ Object.defineProperty(iteratorPrototype, Symbol.iterator, {
 });
 
 [
+    'toString',
+    'toLocaleString',
+    'concat',
     'join',
     'slice',
-    'forEach',
+    'indexOf',
+    'lastIndexOf',
     'every',
     'some',
+    'forEach',
     'find',
     'findIndex',
     'map',
+    'filter',
     'reduce',
     'reduceRight',
 ].forEach(function(methodName) {

lib/index.d.ts

@@ -0,0 +1,440 @@
+////////////////////////////////////////////////////////////////////////////
+//
+// Copyright 2017 Realm Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+////////////////////////////////////////////////////////////////////////////
+
+// TypeScript Version: 2.3.2
+// With great contributions to @akim95 on github
+
+declare namespace Realm {
+    /**
+     * PropertyType
+     * @see { @link https://realm.io/docs/javascript/latest/api/Realm.html#~PropertyType }
+     */
+    type PropertyType = string | 'bool' | 'int' | 'float' | 'double' | 'string' | 'data' | 'date' | 'list';
+
+    /**
+     * ObjectSchemaProperty
+     * @see { @link https://realm.io/docs/javascript/latest/api/Realm.html#~ObjectSchemaProperty }
+     */
+    interface ObjectSchemaProperty {
+        type: PropertyType;
+        objectType?: string;
+        default?: any;
+        optional?: boolean;
+        indexed?: boolean;
+    }
+
+    // properties types
+    interface PropertiesTypes {
+        [keys: string]: PropertyType | ObjectSchemaProperty;
+    }
+
+    /**
+     * ObjectSchema
+     * @see { @link https://realm.io/docs/javascript/latest/api/Realm.html#~ObjectSchema }
+     */
+    interface ObjectSchema {
+        name: string;
+        primaryKey?: string;
+        properties: PropertiesTypes;
+    }
+
+    /**
+     * ObjectClass
+     * @see { @link https://realm.io/docs/javascript/latest/api/Realm.html#~ObjectClass }
+     */
+    interface ObjectClass {
+        schema: ObjectSchema;
+    }
+
+    /**
+     * ObjectType
+     * @see { @link https://realm.io/docs/javascript/latest/api/Realm.html#~ObjectType }
+     */
+    interface ObjectType {
+        type: ObjectClass;
+    }
+
+    /**
+     * realm configuration
+     * @see { @link https://realm.io/docs/javascript/latest/api/Realm.html#~Configuration }
+     */
+    interface Configuration {
+        encryptionKey?: ArrayBuffer | ArrayBufferView | Int8Array;
+        migration?: (oldRealm: Realm, newRealm: Realm) => void;
+        path?: string;
+        readOnly?: boolean;
+        schema?: ObjectClass[] | ObjectSchema[];
+        schemaVersion?: number;
+        sync?: Realm.Sync.SyncConfiguration;
+    }
+
+    // object props type
+    interface ObjectPropsType {
+        [keys: string]: any;
+    }
+
+    /**
+     * Object
+     * @see { @link https://realm.io/docs/javascript/latest/api/Realm.Object.html }
+     */
+    interface Object {
+        /**
+         * @returns boolean
+         */
+        isValid(): boolean;
+
+        /**
+         * @returns ObjectSchema
+         */
+        objectSchema(): ObjectSchema;
+    }
+
+    const Object: {
+        readonly prototype: Object;
+    }
+
+    /**
+     * SortDescriptor
+     * @see { @link https://realm.io/docs/javascript/latest/api/Realm.Collection.html#~SortDescriptor }
+     */
+    type SortDescriptor = string | [string, boolean] | any[];
+
+    interface CollectionChangeSet {
+        insertions: number[];
+        deletions: number[];
+        modifications: number[];
+    }
+
+    type CollectionChangeCallback<T> = (collection: Collection<T>, change: CollectionChangeSet) => void;
+
+    /**
+     * Collection
+     * @see { @link https://realm.io/docs/javascript/latest/api/Realm.Collection.html }
+     */
+    interface Collection<T> extends ReadonlyArray<T> {
+        /**
+         * @returns boolean
+         */
+        isValid(): boolean;
+
+        /**
+         * @param  {string} query
+         * @param  {any[]} ...arg
+         * @returns Results
+         */
+        filtered(query: string, ...arg: any[]): Results<T>;
+
+        /**
+         * @param  {string|SortDescriptor} descriptor
+         * @param  {boolean} reverse?
+         * @returns Results
+         */
+        sorted(descriptor: string | SortDescriptor, reverse?: boolean): Results<T>;
+
+        /**
+         * @returns Results
+         */
+        snapshot(): Results<T>;
+
+        /**
+         * @param  {(collection:any,changes:any)=>void} callback
+         * @returns void
+         */
+        addListener(callback: CollectionChangeCallback<T>): void;
+
+        /**
+         * @returns void
+         */
+        removeAllListeners(): void;
+
+        /**
+         * @param  {()=>void} callback this is the callback to remove
+         * @returns void
+         */
+        removeListener(callback: CollectionChangeCallback<T>): void;
+    }
+
+    const Collection: {
+        readonly prototype: Collection<any>;
+    };
+
+    /**
+     * List
+     * @see { @link https://realm.io/docs/javascript/latest/api/Realm.List.html }
+     */
+    interface List<T> extends Collection<T> {
+        [n: number]: T;
+
+        /**
+         * @returns T
+         */
+        pop(): T | null | undefined;
+
+        /**
+         * @param  {T} object
+         * @returns number
+         */
+        push(object: T): number;
+
+        /**
+         * @returns T
+         */
+        shift(): T | null | undefined;
+
+        /**
+         * @param  {number} index
+         * @param  {number} count?
+         * @param  {any} object?
+         * @returns T
+         */
+        splice(index: number, count?: number, object?: any): T[];
+
+        /**
+         * @param  {T} object
+         * @returns number
+         */
+        unshift(object: T): number;
+    }
+
+    const List: {
+        readonly prototype: List<any>;
+    };
+
+    /**
+     * Results
+     * @see { @link https://realm.io/docs/javascript/latest/api/Realm.Results.html }
+     */
+    interface Results<T> extends Collection<T> {
+
+    }
+
+    const Results: {
+        readonly prototype: Results<any>;
+    };
+}
+
+/**
+ * Sync
+ * @see { @link https://realm.io/docs/javascript/latest/api/Realm.Sync.html }
+ */
+declare namespace Realm.Sync {
+
+    /**
+     * User
+     * @see { @link https://realm.io/docs/javascript/latest/api/Realm.Sync.User.html }
+     */
+    class User {
+        static readonly all: { [identity: string]: User };
+        static readonly current: User;
+        readonly identity: string;
+        readonly isAdmin: boolean;
+        readonly server: string;
+        readonly token: string;
+        static adminUser(adminToken: string): User;
+        static login(server: string, username: string, password: string, callback: (error: any, user: User) => void): void;
+        static loginWithProvider(server: string, provider: string, providerToken: string, callback: (error: any, user: User) => void): void;
+        static register(server: string, username: string, password: string, callback: (error: any, user: User) => void): void;
+        static registerWithProvider(server: string, options: { provider: string, providerToken: string, userInfo: any }, callback: (error: Error | null, user: User | null) => void): void;
+        logout(): void;
+        openManagementRealm(): Realm;
+    }
+
+    interface SyncConfiguration {
+        user: User;
+        url: string;
+        validate_ssl: boolean;
+        ssl_trust_certificate_path: string;
+    }
+
+    /**
+    * Session
+    * @see { @link https://realm.io/docs/javascript/latest/api/Realm.Sync.Session.html }
+    */
+    class Session {
+        readonly config: SyncConfiguration;
+        readonly state: 'invalid' | 'active' | 'inactive';
+        readonly url: string;
+        readonly user: User;
+    }
+
+    /**
+    * AuthError
+    * @see { @link https://realm.io/docs/javascript/latest/api/Realm.Sync.AuthError.html }
+    */
+    class AuthError {
+        readonly code: number;
+        readonly type: string;
+    }
+
+    /**
+     * ChangeEvent
+     * @see { @link https://realm.io/docs/javascript/latest/api/Realm.Sync.ChangeEvent.html }
+     */
+    interface ChangeEvent {
+        readonly changes: { [object_type: string]: CollectionChangeSet };
+        readonly oldRealm: Realm;
+        readonly path: string;
+        readonly realm: Realm;
+    }
+
+    function addListener(serverURL: string, adminUser: Realm.Sync.User, regex: string, name: string, changeCallback: (changeEvent: ChangeEvent) => void): void;
+    function removeAllListeners(name?: string): void;
+    function removeListener(regex: string, name: string, changeCallback: (changeEvent: ChangeEvent) => void): void;
+    function setLogLevel(logLevel: 'error' | 'info' | 'debug'): void;
+    function setAccessToken(accessToken: string): void;
+
+    type Instruction = {
+        type: 'INSERT' | 'SET' | 'DELETE' | 'CLEAR' | 'LIST_SET' | 'LIST_INSERT' | 'LIST_ERASE' | 'LIST_CLEAR' | 'ADD_TYPE' | 'ADD_PROPERTIES'
+        object_type: string,
+        identity: string,
+        values: any | undefined
+        list_index: any | undefined
+        object_identity: any | undefined
+        new_identity: any | undefined,
+        property: any | undefined,
+        properties: any | undefined,
+        primary_key: string | undefined
+    }
+
+    class Adapter {
+        constructor(
+            local_path: string,
+            server_url: string,
+            admin_user: User,
+            regex: string,
+            change_callback: Function
+        )
+
+        /**
+         * Advance the to the next transaction indicating that you are done processing the current instructions for the given Realm.
+         * @param path the path for the Realm to advance
+         */
+        advance(path: string): void;
+        close(): void;
+        current(path: string): Array<Instruction>;
+        realmAtPath(path: string, realmID?: string, schema?: ObjectSchema[]): Realm
+    }
+}
+
+declare class Realm {
+    static defaultPath: string;
+
+    readonly path: string;
+    readonly readOnly: boolean;
+    readonly schema: Realm.ObjectSchema[];
+    readonly schemaVersion: number;
+
+    readonly syncSession: Realm.Sync.Session | null;
+
+    /**
+     * Get the current schema version of the Realm at the given path.
+     * @param  {string} path
+     * @param  {any} encryptionKey?
+     * @returns number
+     */
+    static schemaVersion(path: string, encryptionKey?: ArrayBuffer | ArrayBufferView): number;
+
+    /**
+     * Open a realm asynchronously with a promise. If the realm is synced, it will be fully synchronized before it is available.
+     * @param {Configuration} config 
+     */
+    static open(config: Realm.Configuration): Promise<Realm>
+    /**
+     * Open a realm asynchronously with a callback. If the realm is synced, it will be fully synchronized before it is available.
+     * @param {Configuration} config 
+     * @param {Function} callback will be called when the realm is ready.
+     */
+    static openAsync(config: Realm.Configuration, callback: (error: any, realm: Realm) => void): void
+
+    /**
+     * @param  {Realm.Configuration} config?
+     */
+    constructor(config?: Realm.Configuration);
+
+    /**
+     * @param  {string} path
+     */
+    constructor(path?: string);
+
+    /**
+     * @returns void
+     */
+    close(): void;
+
+    /**
+     * @param  {string|Realm.ObjectClass|Function} type
+     * @param  {T&Realm.ObjectPropsType} properties
+     * @param  {boolean} update?
+     * @returns T
+     */
+    create<T>(type: string | Realm.ObjectClass | Function, properties: T & Realm.ObjectPropsType, update?: boolean): T;
+
+    /**
+     * @param  {Realm.Object|Realm.Object[]|Realm.List<any>|Realm.Results<any>|any} object
+     * @returns void
+     */
+    delete(object: Realm.Object | Realm.Object[] | Realm.List<any> | Realm.Results<any> | any): void;
+
+    /**
+     * @returns void
+     */
+    deleteAll(): void;
+
+    /**
+     * @param  {string|Realm.ObjectSchema|Function} type
+     * @param  {number|string} key
+     * @returns T
+     */
+    objectForPrimaryKey<T>(type: string | Realm.ObjectSchema | Function, key: number | string): T | null;
+
+    /**
+     * @param  {string|Realm.ObjectType|Function} type
+     * @returns Realm
+     */
+    objects<T>(type: string | Realm.ObjectSchema | Function): Realm.Results<T>;
+
+    /**
+     * @param  {string} name
+     * @param  {()=>void} callback
+     * @returns void
+     */
+    addListener(name: string, callback: (sender: Realm, event: 'change') => void): void;
+
+    /**
+     * @param  {string} name
+     * @param  {()=>void} callback
+     * @returns void
+     */
+    removeListener(name: string, callback: (sender: Realm, event: 'change') => void): void;
+
+    /**
+     * @param  {string} name?
+     * @returns void
+     */
+    removeAllListeners(name?: string): void;
+
+    /**
+     * @param  {()=>void} callback
+     * @returns void
+     */
+    write(callback: () => void): void;
+}
+
+declare module 'realm' {
+    export = Realm
+}

package.json

@@ -29,6 +29,7 @@
   "bugs": {
     "url": "https://github.com/realm/realm-js/issues"
   },
+  "typings": "./lib/index.d.ts",
   "main": "lib/index.js",
   "files": [
     "android",