TypeScript Schema.define方法代码示例

import {Schema, arrayOf} from 'normalizr';
import phone from './phone';


const contact = new Schema('contacts',{
    idAttribute: '_id'
});

contact.define({phones: arrayOf(phone)});

export default contact;

import { normalize, Schema, arrayOf, valuesOf } from "normalizr";
export var article = new Schema("articles");
export var comment = new Schema("comments");
export var user = new Schema("users");
article.define({
	get_comments : arrayOf(comment),
	get_author : user,
});

comment.define({
	get_author : user,
	get_article : article,
});

user.define({
	get_articles : arrayOf(article),
	get_comments : arrayOf(comment),
});

/// <reference path="normalizr.d.ts" />

import { normalize, Schema, arrayOf, unionOf, valuesOf } from 'normalizr';

// First, define a schema for our entities:

const article1 = new Schema('articles');
const user1 = new Schema('users');

// Then we define nesting rules:

article1.define({
    author: user1,
    contributors: arrayOf(user1)
});

// Now we can use this schema in our API response handlers:

const ServerActionCreators = {
    // These are two different XHR endpoints with different response schemas.
    // We can use the schema objects defined earlier to express both of them:

    receiveOneArticle(response: any) {
        // Here, the response is an object containing data about one article.
        // Passing the article schema as second parameter to normalize() lets it
        // correctly traverse the response tree and gather all entities:

        // BEFORE:
        // {
        //   id: 1,
        //   title: 'Some Article',

 */
export const interactionSchema = new Schema('interaction', getOptions());
export const draftSchema = new Schema('draft', getOptions());
export const messageSchema = new Schema('message', getOptions());
export const replySchema = new Schema('reply', getOptions());
/**
 * Schema setup for Customer
 */
export const customerSchema = new Schema('customer', getOptions());
export const userSchema = new Schema('user', getOptions());

export const caseChangesSchema = new Schema('changes', getOptions());


interactionSchema.define({
  case: caseSchema
});

customerSchema.define({
  cases: arrayOf(caseSchema)
});

caseSchema.define({
  _embedded: {
    customer: customerSchema, 
    draft: draftSchema,
    message: messageSchema, 
    replies: arrayOf(interactionSchema),
    foober: customerSchema
  },  
});

import { List, Map, Record } from 'immutable'

import {userSchema, IUser} from '../user/user.schema'

export const PostRecord = Record({
  id: null,
  title: null,
  body: null,
  user: null,
  deleting: false
})

export const postSchema = new Schema('posts')

postSchema.define({
  user: userSchema
})


export interface IPost {
  id: string
  title: string
  body: string
  userId: number
  user: any
}

export interface IPosts extends Map<String, any> {
  result: List<Number>
  entities: {
    posts: Map<Number, IPost>,