本文整理汇总了TypeScript中@orbit/data.Schema类的典型用法代码示例。如果您正苦于以下问题:TypeScript Schema类的具体用法?TypeScript Schema怎么用?TypeScript Schema使用的例子?那么, 这里精选的类代码示例或许可以为您提供帮助。
在下文中一共展示了Schema类的10个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的TypeScript代码示例。
示例1: recordRemoved
export function recordRemoved(
schema: Schema,
record: Record
): RecordOperation[] {
const ops: RecordOperation[] = [];
const relationships = record && record.relationships;
if (relationships) {
const modelDef = schema.getModel(record.type);
const recordIdentity = cloneRecordIdentity(record);
Object.keys(relationships).forEach(relationship => {
const relationshipDef = modelDef.relationships[relationship];
const relationshipData =
relationships[relationship] && relationships[relationship].data;
const relatedRecords = recordArrayFromData(relationshipData);
Array.prototype.push.apply(
ops,
removeRelatedRecordsOps(
schema,
recordIdentity,
relationshipDef,
relatedRecords
)
);
});
}
return ops;
}
示例2: normalizeRecordProperties
export default function normalizeRecordProperties(
schema: Schema,
properties: Record<string, unknown>
) {
const { id, type } = properties;
const modelDefinition = schema.getModel(type as string);
const record = { id, type } as OrbitRecord;
assignKeys(modelDefinition, record, properties);
assignAttributes(modelDefinition, record, properties);
assignRelationships(modelDefinition, record, properties);
return record;
}
示例3: recordReplaced
export function recordReplaced(
schema: Schema,
currentRecord: Record,
record: Record
): RecordOperation[] {
const ops: RecordOperation[] = [];
if (record.relationships) {
const modelDef = schema.getModel(record.type);
const recordIdentity = cloneRecordIdentity(record);
for (let relationship in record.relationships) {
const relationshipDef = modelDef.relationships[relationship];
const relationshipData =
record && deepGet(record, ['relationships', relationship, 'data']);
const currentRelationshipData =
currentRecord &&
deepGet(currentRecord, ['relationships', relationship, 'data']);
if (relationshipDef.type === 'hasMany') {
Array.prototype.push.apply(
ops,
relatedRecordsReplaced(
schema,
recordIdentity,
relationship,
currentRelationshipData,
relationshipData
)
);
} else {
Array.prototype.push.apply(
ops,
relatedRecordReplaced(
schema,
recordIdentity,
relationship,
currentRelationshipData,
relationshipData
)
);
}
}
}
return ops;
}
示例4: removeRelationshipOp
export function removeRelationshipOp(
schema: Schema,
record: RecordIdentity,
relationship: string,
relatedRecord: RecordIdentity
): RecordOperation {
const relationshipDef = schema.getModel(record.type).relationships[
relationship
];
const isHasMany = relationshipDef.type === 'hasMany';
return {
op: isHasMany ? 'removeFromRelatedRecords' : 'replaceRelatedRecord',
record,
relationship,
relatedRecord: isHasMany ? relatedRecord : null
} as RecordOperation;
}
示例5: getInverseRelationship
export function getInverseRelationship(
schema: Schema,
record: RecordIdentity,
relationship: string,
relatedRecord: RecordIdentity
): RecordRelationshipIdentity {
if (relatedRecord) {
const relationshipDef = schema.getModel(record.type).relationships[
relationship
];
if (relationshipDef.inverse) {
return {
record,
relationship,
relatedRecord
};
}
}
}
示例6: test
test('#upgrade upgrades the cache to include new models introduced in a schema', async function(assert) {
let person = {
type: 'person',
id: '1',
relationships: { planet: { data: { type: 'planet', id: 'earth' } } }
};
let models = clone(schema.models);
models.planet.relationships.inhabitants = {
type: 'hasMany',
model: 'person',
inverse: 'planet'
};
models.person = {
relationships: {
planet: { type: 'hasOne', model: 'planet', inverse: 'inhabitants' }
}
};
schema.upgrade({ models });
await source.update(t => t.addRecord(person));
assert.deepEqual(
source.cache.getRecordSync({ type: 'person', id: '1' }),
person,
'records match'
);
});
示例7: test
test('Adding a record to the memory source immediately pushes the update to the remote', async function(assert) {
assert.expect(1);
await coordinator.activate();
let planet: Record = {
type: 'planet',
id: schema.generateId(),
attributes: { name: 'Jupiter', classification: 'gas giant' }
};
fetchStub.withArgs('/planets').returns(
jsonapiResponse(201, {
data: {
id: planet.id,
type: 'planets',
attributes: { name: 'Jupiter', classification: 'gas giant' }
}
})
);
await memory.update(t => t.addRecord(planet));
let result = memory.cache.query(q => q.findRecord(planet));
assert.deepEqual(result, {
type: 'planet',
id: planet.id,
attributes: { name: 'Jupiter', classification: 'gas giant' }
});
});
示例8: skip
skip('will reopen the database when the schema is upgraded', async function(assert) {
const done = assert.async();
assert.expect(5);
assert.equal(source.cache.dbVersion, 1, 'db starts with version == 1');
source.cache.migrateDB = function(db, event) {
assert.equal(
event.oldVersion,
1,
'migrateDB called with oldVersion == 1'
);
assert.equal(
event.newVersion,
2,
'migrateDB called with newVersion == 2'
);
done();
};
schema.on('upgrade', version => {
assert.equal(version, 2, 'schema has upgraded to v2');
assert.equal(source.cache.dbVersion, 2, 'db has the correct version');
});
await source.cache.openDB();
await schema.upgrade({
models: {
planet: {
attributes: {
name: { type: 'string' }
}
},
moon: {
attributes: {
name: { type: 'string' }
}
}
}
});
});
示例9:
.then(() => {
schema.upgrade({
models: {
planet: {
attributes: {
name: { type: 'string' }
}
},
moon: {
attributes: {
name: { type: 'string' }
}
}
}
});
});
示例10: test
test('Adding a record to the memory source queues an update request which will be pushed to the remote', async function(assert) {
assert.expect(2);
await coordinator.activate();
fetchStub.withArgs('/planets').returns(
jsonapiResponse(201, {
data: {
id: '12345',
type: 'planets',
attributes: { name: 'Jupiter', classification: 'gas giant' }
}
})
);
let planet: Record = {
type: 'planet',
id: schema.generateId(),
attributes: { name: 'Jupiter', classification: 'gas giant' }
};
await memory.update(t => t.addRecord(planet));
assert.deepEqual(
memory.cache.query(q => q.findRecord(planet)),
{
type: 'planet',
id: planet.id,
attributes: { name: 'Jupiter', classification: 'gas giant' }
},
'keys have not been syncd up yet - remote source still needs to process request'
);
await remote.requestQueue.process();
assert.deepEqual(
memory.cache.query(q => q.findRecord(planet)),
{
type: 'planet',
id: planet.id,
keys: { remoteId: '12345' },
attributes: { name: 'Jupiter', classification: 'gas giant' }
},
'keys are syncd up after remote source finishes processing requests'
);
});