Merge remote-tracking branch 'origin/normalizr3-typings'

Closes gh-189

Author: paularmstrong

index.d.ts

@@ -0,0 +1,57 @@
+declare namespace schema {
+  export type SchemaFunction = (value: any, parent: any, key: string) => string
+  export type MergeFunction = (entityA: any, entityB: any) => any
+
+  export class Array {
+    constructor(definition: Schema, schemaAttribute?: string | SchemaFunction)
+    define(definition: Schema): void
+  }
+
+  export interface EntityOptions {
+    idAttribute?: string | SchemaFunction
+    mergeStrategy?: MergeFunction
+    processStrategy?: SchemaFunction
+  }
+
+  export class Entity {
+    constructor(key: string, definition?: Schema, options?: EntityOptions)
+    define(definition: Schema): void
+    key(): string
+  }
+
+  export class Object {
+    constructor(definition: {[key: string]: Schema})
+    define(definition: Schema): void
+  }
+
+  export class Union {
+    constructor(definition: Schema, schemaAttribute?: string | SchemaFunction)
+    define(definition: Schema): void
+  }
+
+  export class Values {
+    constructor(definition: Schema, schemaAttribute?: string | SchemaFunction)
+    define(definition: Schema): void
+  }
+}
+
+export type Schema =
+  schema.Array |
+  schema.Entity |
+  schema.Object |
+  schema.Union |
+  schema.Values |
+  schema.Array[] |
+  schema.Entity[] |
+  schema.Object[] |
+  schema.Union[] |
+  schema.Values[] |
+  {[key: string]: Schema};
+
+export function normalize(
+  data: any,
+  schema: Schema
+): {
+  entities: any,
+  result: any
+};

package.json

@@ -19,10 +19,12 @@
   ],
   "files": [
     "dist/",
+    "index.d.ts",
     "LICENSE",
     "README.md"
   ],
   "main": "dist/index.js",
+  "typings": "index.d.ts",
   "scripts": {
     "build": "npm run clean && mkdirp dist && npm-run-all --parallel build:development build:production",
     "build:development": "NODE_ENV=development rollup -c",
@@ -56,6 +58,8 @@
     "rollup": "^0.37.0",
     "rollup-plugin-babel": "^2.7.1",
     "rollup-plugin-filesize": "^1.0.1",
-    "rollup-plugin-uglify": "^1.0.1"
+    "rollup-plugin-uglify": "^1.0.1",
+    "typescript": "^2.1.4",
+    "typescript-definition-tester": "0.0.5"
   }
 }

src/__tests__/typescript.test.js

@@ -0,0 +1,13 @@
+/* eslint-env jest */
+import * as path from 'path';
+import { compileDirectory } from 'typescript-definition-tester';
+
+describe('TypeScript definitions', () => {
+  it('compile against index.d.ts', (done) => {
+    compileDirectory(
+      path.resolve(__dirname, 'typescript'),
+      (fileName) => fileName.match(/\.ts$/),
+      done
+    );
+  });
+});

src/__tests__/typescript/array.ts

@@ -0,0 +1,10 @@
+import { normalize, schema } from '../../../index';
+
+const data = [ { id: '123', name: 'Jim' }, { id: '456', name: 'Jane' } ];
+const userSchema = new schema.Entity('users');
+
+const userListSchema = new schema.Array(userSchema);
+const normalizedData = normalize(data, userListSchema);
+
+const userListSchemaAlt = [ userSchema ];
+const normalizedDataAlt = normalize(data, userListSchemaAlt);

src/__tests__/typescript/array_schema.ts

@@ -0,0 +1,12 @@
+import { normalize, schema } from '../../../index';
+
+const data = [ { id: 1, type: 'admin' }, { id: 2, type: 'user' } ];
+const userSchema = new schema.Entity('users');
+const adminSchema = new schema.Entity('admins');
+
+const myArray = new schema.Array({
+  admins: adminSchema,
+  users: userSchema
+}, (input, parent, key) => `${input.type}s`);
+
+const normalizedData = normalize(data, myArray);

src/__tests__/typescript/entity.ts

@@ -0,0 +1,20 @@
+import { normalize, schema } from '../../../index';
+
+const data = {/*...*/};
+const user = new schema.Entity('users', {}, { idAttribute: 'id_str' });
+const tweet = new schema.Entity('tweets', { user: user }, {
+    idAttribute: 'id_str',
+    // Apply everything from entityB over entityA, except for "favorites"
+    mergeStrategy: (entityA, entityB) => ({
+      ...entityA,
+      ...entityB,
+      favorites: entityA.favorites
+    }),
+    // Remove the URL field from the entity
+    processStrategy: (entity) => {
+      const {url, ...entityWithoutUrl} = entity;
+      return entityWithoutUrl;
+    }
+});
+
+const normalizedData = normalize(data, tweet);

src/__tests__/typescript/github.ts

@@ -0,0 +1,34 @@
+import { normalize, schema } from '../../../index';
+
+const user = new schema.Entity('users');
+
+const label = new schema.Entity('labels');
+
+const milestone = new schema.Entity('milestones', {
+  creator: user
+});
+
+const issue = new schema.Entity('issues', {
+  assignee: user,
+  assignees: [ user ],
+  labels: label,
+  milestone,
+  user
+});
+
+const pullRequest = new schema.Entity('pullRequests', {
+  assignee: user,
+  assignees: [ user ],
+  labels: label,
+  milestone,
+  user
+});
+
+const issueOrPullRequest = new schema.Array({
+  issues: issue,
+  pullRequests: pullRequest
+}, (entity: any) => entity.pull_request ? 'pullRequests' : 'issues');
+
+const data = {/*...*/};
+const normalizedData = normalize(data, issueOrPullRequest);
+console.log(normalizedData);

src/__tests__/typescript/object.ts

@@ -0,0 +1,10 @@
+import { normalize, schema } from '../../../index';
+
+const data = {/*...*/};
+const user = new schema.Entity('users');
+
+const responseSchema = new schema.Object({ users: new schema.Array(user) });
+const normalizedData = normalize(data, responseSchema);
+
+const responseSchemaAlt = { users: new schema.Array(user) };
+const normalizedDataAlt = normalize(data, responseSchemaAlt);

src/__tests__/typescript/relationships.ts

@@ -0,0 +1,43 @@
+import { normalize, schema } from '../../../index';
+
+const userProcessStrategy = (value: any, parent: any, key: string) => {
+  switch (key) {
+    case 'author':
+      return { ...value, posts: [ parent.id ] };
+    case 'commenter':
+      return { ...value, comments: [ parent.id ] };
+    default:
+      return { ...value };
+  }
+};
+
+const userMergeStrategy = (entityA: any, entityB: any) => {
+  return {
+    ...entityA,
+    ...entityB,
+    posts: [ ...(entityA.posts || []), ...(entityB.posts || []) ],
+    comments: [ ...(entityA.comments || []), ...(entityB.comments || []) ]
+  };
+};
+
+const user = new schema.Entity('users', {}, {
+  mergeStrategy: userMergeStrategy,
+  processStrategy: userProcessStrategy
+});
+
+const comment = new schema.Entity('comments', {
+  commenter: user
+}, {
+  processStrategy: (value: any, parent: any, key: string) => {
+    return { ...value, post: parent.id };
+  }
+});
+
+const post = new schema.Entity('posts', {
+  author: user,
+  comments: [ comment ]
+});
+
+const data = {/*...*/};
+const normalizedData = normalize(data, post);
+console.log(normalizedData);

src/__tests__/typescript/union.ts

@@ -0,0 +1,12 @@
+import { normalize, schema } from '../../../index';
+
+const data = { owner: { id: 1, type: 'user' } };
+
+const user = new schema.Entity('users');
+const group = new schema.Entity('groups');
+const unionSchema = new schema.Union({
+  user: user,
+  group: group
+}, 'type');
+
+const normalizedData = normalize(data, { owner: unionSchema });

src/__tests__/typescript/values.ts

@@ -0,0 +1,8 @@
+import { normalize, schema } from '../../../index';
+
+const data = { firstThing: { id: 1 }, secondThing: { id: 2 } };
+
+const item = new schema.Entity('items');
+const valuesSchema = new schema.Values(item);
+
+const normalizedData = normalize(data, valuesSchema);