TypeScript data.Schema類代碼示例

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;
}

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;
}

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;
}

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;
}

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
      };
    }
  }
}

  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'
    );
  });

    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' }
      });
    });

  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' }
          }
        }
      }
    });
  });

 .then(() => {
   schema.upgrade({
     models: {
       planet: {
         attributes: {
           name: { type: 'string' }
         }
       },
       moon: {
         attributes: {
           name: { type: 'string' }
         }
       }
     }
   });
 });

  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'
    );
  });