breeze-client 2.1.2 → 2.1.3-mjs

package/esm2020/src/key-generator.mjs

@@ -0,0 +1,108 @@
+import { EntityKey } from './entity-key';
+import { config } from './config';
+/*
+  @class KeyGenerator
+  */
+export class KeyGenerator {
+    constructor() {
+        // key is dataProperty.name + || + entityType.name, value is propEntry
+        // propEntry = { entityType, propertyName, keyMap }
+        // keyMap has key of the actual value ( as a string) and a value of null or the real id.
+        this._tempIdMap = {};
+    }
+    /*
+    Returns a unique 'temporary' id for the specified [[EntityType]].
+    Uniqueness is defined for this purpose as being unique within each instance of a KeyGenerator. This is sufficient
+    because each EntityManager will have its own instance of a KeyGenerator and any entities imported into
+    the EntityManager with temporary keys will have them regenerated and remapped on import.
+  
+    The return value of this method must be of the correct type as determined by the keyProperties of the
+    specified EntityType
+    @example
+        // Assume em1 is a preexisting EntityManager
+        let custType = em1.metadataStore.getEntityType("Customer");
+        let cust1 = custType.createEntity();
+        // next line both sets cust1's 'CustomerId' property but also returns the value
+        let cid1 = em1.generateTempKeyValue(cust1);
+        em1.saveChanges().then( function( data) {
+          let sameCust1 = data.results[0];
+          // cust1 === sameCust1;
+          // but cust1.getProperty("CustomerId") != cid1
+          // because the server will have generated a new id
+          // and the client will have been updated with this
+          // new id.
+        });
+    @method generateTempKeyValue
+    @param entityType {EntityType}
+    */
+    generateTempKeyValue(entityType, valueIfAvail) {
+        let keyProps = entityType.keyProperties;
+        if (keyProps.length > 1) {
+            throw new Error("Ids can not be autogenerated for entities with multipart keys");
+        }
+        let keyProp = keyProps[0];
+        let propEntry = this._getPropEntry(keyProp, true);
+        let nextId;
+        if (valueIfAvail != null) {
+            if (!propEntry.keyMap[valueIfAvail.toString()]) {
+                nextId = valueIfAvail;
+            }
+        }
+        if (nextId === undefined) {
+            let dataType = keyProp.dataType;
+            let getNextFn = dataType.getNext;
+            if (getNextFn) {
+                nextId = getNextFn(this);
+                // need to watch out for collision with previously imported ids that might also get generated.
+                while (propEntry.keyMap[nextId.toString()] != null) {
+                    nextId = getNextFn(this);
+                }
+            }
+            else {
+                throw new Error("Cannot use a property with a dataType of: " + dataType.toString() + " for id generation");
+            }
+        }
+        propEntry.keyMap[nextId.toString()] = true;
+        return nextId;
+    }
+    getTempKeys() {
+        let results = [];
+        //noinspection JSHint
+        for (let key in this._tempIdMap) {
+            let propEntry = this._tempIdMap[key];
+            let entityType = propEntry.entityType;
+            // let propName = propEntry.propertyName;
+            //noinspection JSHint
+            for (let keyValue in propEntry.keyMap) {
+                results.push(new EntityKey(entityType, [keyValue]));
+            }
+        }
+        return results;
+    }
+    // proto methods below are not part of the KeyGenerator interface.
+    isTempKey(entityKey) {
+        let keyProps = entityKey.entityType.keyProperties;
+        if (keyProps.length > 1)
+            return false;
+        let keyProp = keyProps[0];
+        let propEntry = this._getPropEntry(keyProp);
+        if (!propEntry) {
+            return false;
+        }
+        return (propEntry.keyMap[entityKey.values[0].toString()] !== undefined);
+    }
+    /** @hidden @internal */
+    _getPropEntry(keyProp, createIfMissing = false) {
+        let key = keyProp.name + ".." + keyProp.parentType.name;
+        let propEntry = this._tempIdMap[key];
+        if (!propEntry) {
+            if (createIfMissing) {
+                propEntry = { entityType: keyProp.parentType, propertyName: keyProp.name, keyMap: {} };
+                this._tempIdMap[key] = propEntry;
+            }
+        }
+        return propEntry;
+    }
+}
+config.registerType(KeyGenerator, "KeyGenerator");
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"key-generator.js","sourceRoot":"","sources":["../../../src/key-generator.ts"],"names":[],"mappings":"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","sourcesContent":["import { EntityType, DataProperty } from './entity-metadata';\r\nimport { EntityKey } from './entity-key';\r\nimport { config } from './config';\r\n\r\ninterface IPropEntry {\r\n  entityType: EntityType;\r\n  propertyName: string;\r\n  keyMap: Object;\r\n}\r\n\r\ninterface ITempIdMap {\r\n  [index: string]: IPropEntry;\r\n}\r\n\r\n/*\r\n  @class KeyGenerator\r\n  */\r\nexport class KeyGenerator {\r\n  /** @hidden @internal */\r\n  private _tempIdMap: ITempIdMap;\r\n\r\n\r\n  constructor() {\r\n    // key is dataProperty.name + || + entityType.name, value is propEntry\r\n    // propEntry = { entityType, propertyName, keyMap }\r\n    // keyMap has key of the actual value ( as a string) and a value of null or the real id.\r\n    this._tempIdMap = {};\r\n  }\r\n\r\n\r\n  /*\r\n  Returns a unique 'temporary' id for the specified [[EntityType]].\r\n  Uniqueness is defined for this purpose as being unique within each instance of a KeyGenerator. This is sufficient\r\n  because each EntityManager will have its own instance of a KeyGenerator and any entities imported into\r\n  the EntityManager with temporary keys will have them regenerated and remapped on import.\r\n\r\n  The return value of this method must be of the correct type as determined by the keyProperties of the\r\n  specified EntityType\r\n  @example\r\n      // Assume em1 is a preexisting EntityManager\r\n      let custType = em1.metadataStore.getEntityType(\"Customer\");\r\n      let cust1 = custType.createEntity();\r\n      // next line both sets cust1's 'CustomerId' property but also returns the value\r\n      let cid1 = em1.generateTempKeyValue(cust1);\r\n      em1.saveChanges().then( function( data) {\r\n        let sameCust1 = data.results[0];\r\n        // cust1 === sameCust1;\r\n        // but cust1.getProperty(\"CustomerId\") != cid1\r\n        // because the server will have generated a new id\r\n        // and the client will have been updated with this\r\n        // new id.\r\n      });\r\n  @method generateTempKeyValue\r\n  @param entityType {EntityType}\r\n  */\r\n  generateTempKeyValue(entityType: EntityType, valueIfAvail?: boolean) {\r\n    let keyProps = entityType.keyProperties;\r\n    if (keyProps.length > 1) {\r\n      throw new Error(\"Ids can not be autogenerated for entities with multipart keys\");\r\n    }\r\n    let keyProp = keyProps[0];\r\n    let propEntry = this._getPropEntry(keyProp, true);\r\n    let nextId: any;\r\n    if (valueIfAvail != null) {\r\n      if (!propEntry.keyMap[valueIfAvail.toString()]) {\r\n        nextId = valueIfAvail;\r\n      }\r\n    }\r\n\r\n    if (nextId === undefined) {\r\n      let dataType = keyProp.dataType;\r\n      let getNextFn = (dataType as any).getNext;\r\n      if (getNextFn) {\r\n        nextId = getNextFn(this);\r\n        // need to watch out for collision with previously imported ids that might also get generated.\r\n        while (propEntry.keyMap[nextId.toString()] != null) {\r\n          nextId = getNextFn(this);\r\n        }\r\n      } else {\r\n        throw new Error(\"Cannot use a property with a dataType of: \" + dataType.toString() + \" for id generation\");\r\n      }\r\n    }\r\n\r\n    propEntry.keyMap[nextId.toString()] = true;\r\n    return nextId;\r\n  }\r\n\r\n  getTempKeys() {\r\n    let results: EntityKey[] = [];\r\n    //noinspection JSHint\r\n    for (let key in this._tempIdMap) {\r\n      let propEntry = this._tempIdMap[key];\r\n      let entityType = propEntry.entityType;\r\n      // let propName = propEntry.propertyName;\r\n      //noinspection JSHint\r\n      for (let keyValue in propEntry.keyMap) {\r\n        results.push(new EntityKey(entityType, [keyValue]));\r\n      }\r\n    }\r\n    return results;\r\n  }\r\n\r\n\r\n  // proto methods below are not part of the KeyGenerator interface.\r\n\r\n  isTempKey(entityKey: EntityKey) {\r\n    let keyProps = entityKey.entityType.keyProperties;\r\n    if (keyProps.length > 1) return false;\r\n    let keyProp = keyProps[0];\r\n    let propEntry = this._getPropEntry(keyProp);\r\n    if (!propEntry) {\r\n      return false;\r\n    }\r\n    return (propEntry.keyMap[entityKey.values[0].toString()] !== undefined);\r\n  }\r\n\r\n  /** @hidden @internal */\r\n  private _getPropEntry(keyProp: DataProperty, createIfMissing = false) {\r\n    let key = keyProp.name + \"..\" + keyProp.parentType.name;\r\n    let propEntry = this._tempIdMap[key];\r\n    if (!propEntry) {\r\n      if (createIfMissing) {\r\n        propEntry = { entityType: keyProp.parentType as EntityType, propertyName: keyProp.name, keyMap: {} };\r\n        this._tempIdMap[key] = propEntry;\r\n      }\r\n    }\r\n    return propEntry;\r\n  }\r\n\r\n}\r\n\r\nconfig.registerType(KeyGenerator, \"KeyGenerator\");\r\n\r\n"]}

package/esm2020/src/local-query-comparison-options.mjs

@@ -0,0 +1,65 @@
+import { core } from './core';
+import { assertConfig } from './assert-param';
+import { config } from './config';
+/**
+A LocalQueryComparisonOptions instance is used to specify the "comparison rules" used when performing "local queries" in order
+to match the semantics of these same queries when executed against a remote service.  These options should be set based on the
+manner in which your remote service interprets certain comparison operations.
+
+The default LocalQueryComparisonOptions stipulates 'caseInsensitive" queries with ANSI SQL rules regarding comparisons of unequal
+length strings.
+**/
+export class LocalQueryComparisonOptions {
+    /**
+    LocalQueryComparisonOptions constructor
+    >      // create a 'caseSensitive - non SQL' instance.
+    >      var lqco = new LocalQueryComparisonOptions({
+    >              name: "caseSensitive-nonSQL"
+    >              isCaseSensitive: true;
+    >              usesSql92CompliantStringComparison: false;
+    >          });
+    >      // either apply it globally
+    >      lqco.setAsDefault();
+    >      // or to a specific MetadataStore
+    >      var ms = new MetadataStore({ localQueryComparisonOptions: lqco });
+    >      var em = new EntityManager( { metadataStore: ms });
+    @param config - A configuration object.
+    **/
+    constructor(lqcoConfig) {
+        assertConfig(lqcoConfig || {})
+            .whereParam("name").isOptional().isString()
+            .whereParam("isCaseSensitive").isOptional().isBoolean()
+            .whereParam("usesSql92CompliantStringComparison").isBoolean()
+            .applyAll(this);
+        if (!this.name) {
+            this.name = core.getUuid();
+        }
+        config._storeObject(this, "LocalQueryComparisonOptions", this.name);
+    }
+    /**
+    Sets the 'defaultInstance' by creating a copy of the current 'defaultInstance' and then applying all of the properties of the current instance.
+    The current instance is returned unchanged.
+    >     var lqco = new LocalQueryComparisonOptions({
+    >        isCaseSensitive: false;
+    >        usesSql92CompliantStringComparison: true;
+    >     });
+    >     lqco.setAsDefault();
+    **/
+    setAsDefault() {
+        return core.setAsDefault(this, LocalQueryComparisonOptions);
+    }
+}
+/**
+Case insensitive SQL compliant options - this is also the default unless otherwise changed.
+**/
+LocalQueryComparisonOptions.caseInsensitiveSQL = new LocalQueryComparisonOptions({
+    name: "caseInsensitiveSQL",
+    isCaseSensitive: false,
+    usesSql92CompliantStringComparison: true
+});
+/**
+The default value whenever LocalQueryComparisonOptions are not specified. By default this is 'caseInsensitiveSQL'.
+**/
+LocalQueryComparisonOptions.defaultInstance = new LocalQueryComparisonOptions(LocalQueryComparisonOptions.caseInsensitiveSQL);
+LocalQueryComparisonOptions.prototype._$typeName = "LocalQueryComparisonOptions";
+//# sourceMappingURL=data:application/json;base64,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