breeze-client 2.2.2 → 3.0.0

package/{src → metadata}/local-query-comparison-options.d.ts

@@ -1,59 +1,65 @@
-/** Configuration info to be passed to the [[LocalQueryComparisonOptions]] constructor. */
-export interface LocalQueryComparisonOptionsConfig {
-    /** The name of this collection of configuration settings. */
-    name?: string;
-    /** Whether predicates that involve strings will be interpreted in a "caseSensitive" manner. Default is 'false'. */
-    isCaseSensitive?: boolean;
-    usesSql92CompliantStringComparison?: boolean;
-}
-/**
-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 declare class LocalQueryComparisonOptions {
-    /** @hidden @internal */
-    _$typeName: string;
-    /** The name for this instance. */
-    name: string;
-    /** Whether predicates that involve strings will be interpreted in a "caseSensitive" manner. (default = false).  */
-    isCaseSensitive: boolean;
-    usesSql92CompliantStringComparison: boolean;
-    /**
-    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: LocalQueryComparisonOptionsConfig);
-    /**
-    Case insensitive SQL compliant options - this is also the default unless otherwise changed.
-    **/
-    static caseInsensitiveSQL: LocalQueryComparisonOptions;
-    /**
-    The default value whenever LocalQueryComparisonOptions are not specified. By default this is 'caseInsensitiveSQL'.
-    **/
-    static defaultInstance: LocalQueryComparisonOptions;
-    /**
-    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(): any;
-}
+/** Configuration info to be passed to the {@link LocalQueryComparisonOptions} constructor. */
+export interface LocalQueryComparisonOptionsConfig {
+    /** The name of this collection of configuration settings. */
+    name?: string;
+    /** Whether predicates that involve strings will be interpreted in a "caseSensitive" manner. Default is 'false'. */
+    isCaseSensitive?: boolean;
+    /** Whether or not to enforce the ANSI SQL standard
+    of padding strings of unequal lengths before comparison with spaces. Note that per the standard, padding only occurs with equality and
+    inequality predicates, and not with operations like 'startsWith', 'endsWith' or 'contains'.  Default is true. */
+    usesSql92CompliantStringComparison?: boolean;
+}
+/**
+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 declare class LocalQueryComparisonOptions {
+    /** The name for this instance. */
+    name: string;
+    /** Whether predicates that involve strings will be interpreted in a "caseSensitive" manner. (default = false).  */
+    isCaseSensitive: boolean;
+    /** Whether `==` and `!=` comparisons of strings ignore leading and trailing spaces, to match a SQL server's comparison of strings of unequal length. `startsWith`, `endsWith` and `contains` are unaffected. (default = true). */
+    usesSql92CompliantStringComparison: boolean;
+    /**
+    LocalQueryComparisonOptions constructor
+    ```ts
+    // 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 lqcoConfig - A configuration object.
+    */
+    constructor(lqcoConfig: LocalQueryComparisonOptionsConfig);
+    /**
+    Case insensitive SQL compliant options - this is also the default unless otherwise changed.
+    */
+    static caseInsensitiveSQL: LocalQueryComparisonOptions;
+    /**
+    The default value whenever LocalQueryComparisonOptions are not specified. By default this is 'caseInsensitiveSQL'.
+    */
+    static defaultInstance: LocalQueryComparisonOptions;
+    /**
+    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.
+    ```ts
+    var lqco = new LocalQueryComparisonOptions({
+       isCaseSensitive: false;
+       usesSql92CompliantStringComparison: true;
+    });
+    lqco.setAsDefault();
+    ```
+    */
+    setAsDefault(): any;
+}

package/metadata/local-query-comparison-options.js

@@ -0,0 +1,69 @@
+import { core, getUuid } from '../core/core.js';
+import { assertConfig } from '../core/assert-param.js';
+import { config } from '../config/config.js';
+/**
+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
+    ```ts
+    // 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 lqcoConfig - A configuration object.
+    */
+    constructor(lqcoConfig) {
+        assertConfig(lqcoConfig || {})
+            .whereParam("name").isOptional().isString()
+            .whereParam("isCaseSensitive").isOptional().isBoolean().withDefault(false)
+            .whereParam("usesSql92CompliantStringComparison").isOptional().isBoolean().withDefault(true)
+            .applyAll(this);
+        if (!this.name) {
+            this.name = getUuid();
+        }
+        config._storeObject(this, "LocalQueryComparisonOptions", this.name);
+    }
+    /**
+    Case insensitive SQL compliant options - this is also the default unless otherwise changed.
+    */
+    static caseInsensitiveSQL = new LocalQueryComparisonOptions({
+        name: "caseInsensitiveSQL",
+        isCaseSensitive: false,
+        usesSql92CompliantStringComparison: true
+    });
+    /**
+    The default value whenever LocalQueryComparisonOptions are not specified. By default this is 'caseInsensitiveSQL'.
+    */
+    static defaultInstance = new LocalQueryComparisonOptions(LocalQueryComparisonOptions.caseInsensitiveSQL);
+    /**
+    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.
+    ```ts
+    var lqco = new LocalQueryComparisonOptions({
+       isCaseSensitive: false;
+       usesSql92CompliantStringComparison: true;
+    });
+    lqco.setAsDefault();
+    ```
+    */
+    setAsDefault() {
+        return core.setAsDefault(this, LocalQueryComparisonOptions);
+    }
+}
+LocalQueryComparisonOptions.prototype._$typeName = "LocalQueryComparisonOptions";
+//# sourceMappingURL=local-query-comparison-options.js.map

package/metadata/local-query-comparison-options.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"local-query-comparison-options.js","sourceRoot":"","sources":["../../src/metadata/local-query-comparison-options.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AACvD,OAAO,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAe7C;;;;;;;EAOE;AACF,MAAM,OAAO,2BAA2B;IAatC;;;;;;;;;;;;;;;;MAgBE;IACF,YAAY,UAA6C;QACvD,YAAY,CAAC,UAAU,IAAI,EAAE,CAAC;aACzB,UAAU,CAAC,MAAM,CAAC,CAAC,UAAU,EAAE,CAAC,QAAQ,EAAE;aAC1C,UAAU,CAAC,iBAAiB,CAAC,CAAC,UAAU,EAAE,CAAC,SAAS,EAAE,CAAC,WAAW,CAAC,KAAK,CAAC;aACzE,UAAU,CAAC,oCAAoC,CAAC,CAAC,UAAU,EAAE,CAAC,SAAS,EAAE,CAAC,WAAW,CAAC,IAAI,CAAC;aAC3F,QAAQ,CAAC,IAAI,CAAC,CAAC;QACpB,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC;YACf,IAAI,CAAC,IAAI,GAAG,OAAO,EAAE,CAAC;QACxB,CAAC;QACD,MAAM,CAAC,YAAY,CAAC,IAAI,EAAE,6BAA6B,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC;IACtE,CAAC;IAED;;MAEE;IACF,MAAM,CAAC,kBAAkB,GAAG,IAAI,2BAA2B,CAAC;QAC1D,IAAI,EAAE,oBAAoB;QAC1B,eAAe,EAAE,KAAK;QACtB,kCAAkC,EAAE,IAAI;KACzC,CAAC,CAAC;IAEH;;MAEE;IACF,MAAM,CAAC,eAAe,GAAG,IAAI,2BAA2B,CAAC,2BAA2B,CAAC,kBAAkB,CAAC,CAAC;IAEzG;;;;;;;;;;MAUE;IACF,YAAY;QACV,OAAO,IAAI,CAAC,YAAY,CAAC,IAAI,EAAE,2BAA2B,CAAC,CAAC;IAC9D,CAAC;;AAGH,2BAA2B,CAAC,SAAS,CAAC,UAAU,GAAG,6BAA6B,CAAC","sourcesContent":["import { core, getUuid } from '../core/core.js';\r\nimport { assertConfig } from '../core/assert-param.js';\r\nimport { config } from '../config/config.js';\r\n\r\n\r\n/** Configuration info to be passed to the {@link LocalQueryComparisonOptions} constructor. */\r\nexport interface LocalQueryComparisonOptionsConfig {\r\n  /** The name of this collection of configuration settings. */\r\n  name?: string;\r\n  /** Whether predicates that involve strings will be interpreted in a \"caseSensitive\" manner. Default is 'false'. */\r\n  isCaseSensitive?: boolean;\r\n  /** Whether or not to enforce the ANSI SQL standard\r\n  of padding strings of unequal lengths before comparison with spaces. Note that per the standard, padding only occurs with equality and\r\n  inequality predicates, and not with operations like 'startsWith', 'endsWith' or 'contains'.  Default is true. */\r\n  usesSql92CompliantStringComparison?: boolean;\r\n}\r\n\r\n/**\r\nA LocalQueryComparisonOptions instance is used to specify the \"comparison rules\" used when performing \"local queries\" in order\r\nto match the semantics of these same queries when executed against a remote service.  These options should be set based on the\r\nmanner in which your remote service interprets certain comparison operations.\r\n\r\nThe default LocalQueryComparisonOptions stipulates 'caseInsensitive\" queries with ANSI SQL rules regarding comparisons of unequal\r\nlength strings.\r\n*/\r\nexport class LocalQueryComparisonOptions {\r\n  /** @hidden @internal */\r\n  declare _$typeName: string; // on prototype\r\n  /** The name for this instance. */\r\n  declare name: string;\r\n  /** Whether predicates that involve strings will be interpreted in a \"caseSensitive\" manner. (default = false).  */\r\n  declare isCaseSensitive: boolean;\r\n  /** Whether `==` and `!=` comparisons of strings ignore leading and trailing spaces, to match a SQL server's comparison of strings of unequal length. `startsWith`, `endsWith` and `contains` are unaffected. (default = true). */\r\n  /* Whether or not to enforce the ANSI SQL standard\r\n  of padding strings of unequal lengths before comparison with spaces. Note that per the standard, padding only occurs with equality and\r\n  inequality predicates, and not with operations like 'startsWith', 'endsWith' or 'contains'.  Default is true. */\r\n  declare usesSql92CompliantStringComparison: boolean;\r\n\r\n  /**\r\n  LocalQueryComparisonOptions constructor\r\n  ```ts\r\n  // create a 'caseSensitive - non SQL' instance.\r\n  var lqco = new LocalQueryComparisonOptions({\r\n          name: \"caseSensitive-nonSQL\"\r\n          isCaseSensitive: true;\r\n          usesSql92CompliantStringComparison: false;\r\n      });\r\n  // either apply it globally\r\n  lqco.setAsDefault();\r\n  // or to a specific MetadataStore\r\n  var ms = new MetadataStore({ localQueryComparisonOptions: lqco });\r\n  var em = new EntityManager( { metadataStore: ms });\r\n  ```\r\n  @param lqcoConfig - A configuration object.\r\n  */\r\n  constructor(lqcoConfig: LocalQueryComparisonOptionsConfig) {\r\n    assertConfig(lqcoConfig || {})\r\n        .whereParam(\"name\").isOptional().isString()\r\n        .whereParam(\"isCaseSensitive\").isOptional().isBoolean().withDefault(false)\r\n        .whereParam(\"usesSql92CompliantStringComparison\").isOptional().isBoolean().withDefault(true)\r\n        .applyAll(this);\r\n    if (!this.name) {\r\n      this.name = getUuid();\r\n    }\r\n    config._storeObject(this, \"LocalQueryComparisonOptions\", this.name);\r\n  }\r\n\r\n  /**\r\n  Case insensitive SQL compliant options - this is also the default unless otherwise changed.\r\n  */\r\n  static caseInsensitiveSQL = new LocalQueryComparisonOptions({\r\n    name: \"caseInsensitiveSQL\",\r\n    isCaseSensitive: false,\r\n    usesSql92CompliantStringComparison: true\r\n  });\r\n\r\n  /**\r\n  The default value whenever LocalQueryComparisonOptions are not specified. By default this is 'caseInsensitiveSQL'.\r\n  */\r\n  static defaultInstance = new LocalQueryComparisonOptions(LocalQueryComparisonOptions.caseInsensitiveSQL);\r\n\r\n  /**\r\n  Sets the 'defaultInstance' by creating a copy of the current 'defaultInstance' and then applying all of the properties of the current instance.\r\n  The current instance is returned unchanged.\r\n  ```ts\r\n  var lqco = new LocalQueryComparisonOptions({\r\n     isCaseSensitive: false;\r\n     usesSql92CompliantStringComparison: true;\r\n  });\r\n  lqco.setAsDefault();\r\n  ```\r\n  */\r\n  setAsDefault() {\r\n    return core.setAsDefault(this, LocalQueryComparisonOptions);\r\n  }\r\n\r\n}\r\nLocalQueryComparisonOptions.prototype._$typeName = \"LocalQueryComparisonOptions\";\r\n"]}

package/{src → metadata}/naming-convention.d.ts

@@ -1,72 +1,75 @@
-/** Configuration info to be passed to the [[NamingConvention]] constructor */
-export interface NamingConventionConfig {
-    /** The name of this NamingConvention */
-    name?: string;
-    /** Function that takes a server property name add converts it into a client side property name.  */
-    serverPropertyNameToClient?: (nm: string, context?: any) => string;
-    /** Function that takes a client property name add converts it into a server side property name. */
-    clientPropertyNameToServer?: (nm: string, context?: any) => string;
-}
-/**
-A NamingConvention instance is used to specify the naming conventions under which a MetadataStore
-will translate property names between the server and the javascript client.
-
-The default NamingConvention does not perform any translation, it simply passes property names thru unchanged.
-@dynamic
-**/
-export declare class NamingConvention {
-    /** @hidden @internal */
-    _$typeName: string;
-    /** The name of this NamingConvention. __Read Only__ */
-    name: string;
-    /** Function that takes a server property name add converts it into a client side property name.  __Read Only__ */
-    serverPropertyNameToClient: (nm: string, context?: any) => string;
-    /** Function that takes a client property name add converts it into a server side property name. __Read Only__ */
-    clientPropertyNameToServer: (nm: string, context?: any) => string;
-    /**
-    NamingConvention constructor
-    >      // A naming convention that converts the first character of every property name to uppercase on the server
-    >      // and lowercase on the client.
-    >      var namingConv = new NamingConvention({
-    >          serverPropertyNameToClient: function(serverPropertyName) {
-    >              return serverPropertyName.substr(0, 1).toLowerCase() + serverPropertyName.substr(1);
-    >          },
-    >          clientPropertyNameToServer: function(clientPropertyName) {
-    >              return clientPropertyName.substr(0, 1).toUpperCase() + clientPropertyName.substr(1);
-    >          }
-    >      });
-    >      var ms = new MetadataStore({ namingConvention: namingConv });
-    >      var em = new EntityManager( { metadataStore: ms });
-    **/
-    constructor(ncConfig: NamingConventionConfig);
-    /**
-  
-  
-    /**
-    A noop naming convention - This is the default unless another is specified.
-    **/
-    static none: NamingConvention;
-    /**
-    The "camelCase" naming convention - This implementation only lowercases the first character of the server property name
-    but leaves the rest of the property name intact.  If a more complicated version is needed then one should be created via the ctor.
-    **/
-    static camelCase: NamingConvention;
-    /**
-    The default value whenever NamingConventions are not specified.
-    **/
-    static defaultInstance: NamingConvention;
-    /**
-    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 namingConv = new NamingConvention({
-    >          serverPropertyNameToClient: function(serverPropertyName) {
-    >              return serverPropertyName.substr(0, 1).toLowerCase() + serverPropertyName.substr(1);
-    >          },
-    >          clientPropertyNameToServer: function(clientPropertyName) {
-    >              return clientPropertyName.substr(0, 1).toUpperCase() + clientPropertyName.substr(1);
-    >          }
-    >      });
-    >      namingConv.setAsDefault();
-    **/
-    setAsDefault(): any;
-}
+/** Configuration info to be passed to the {@link NamingConvention} constructor */
+export interface NamingConventionConfig {
+    /** The name of this NamingConvention */
+    name?: string;
+    /** Function that takes a server property name add converts it into a client side property name.  */
+    serverPropertyNameToClient?: (nm: string, context?: any) => string;
+    /** Function that takes a client property name add converts it into a server side property name. */
+    clientPropertyNameToServer?: (nm: string, context?: any) => string;
+}
+/**
+A NamingConvention instance is used to specify the naming conventions under which a MetadataStore
+will translate property names between the server and the javascript client.
+
+The default NamingConvention does not perform any translation, it simply passes property names thru unchanged.
+*/
+export declare class NamingConvention {
+    /** The name of this NamingConvention. __Read Only__ */
+    name: string;
+    /** Function that takes a server property name add converts it into a client side property name.  __Read Only__ */
+    serverPropertyNameToClient: (nm: string, context?: any) => string;
+    /** Function that takes a client property name add converts it into a server side property name. __Read Only__ */
+    clientPropertyNameToServer: (nm: string, context?: any) => string;
+    /**
+    NamingConvention constructor
+    ```ts
+    // A naming convention that converts the first character of every property name to uppercase on the server
+    // and lowercase on the client.
+    var namingConv = new NamingConvention({
+        serverPropertyNameToClient: function(serverPropertyName) {
+            return serverPropertyName.substr(0, 1).toLowerCase() + serverPropertyName.substr(1);
+        },
+        clientPropertyNameToServer: function(clientPropertyName) {
+            return clientPropertyName.substr(0, 1).toUpperCase() + clientPropertyName.substr(1);
+        }
+    });
+    var ms = new MetadataStore({ namingConvention: namingConv });
+    var em = new EntityManager( { metadataStore: ms });
+    ```
+    */
+    constructor(ncConfig: NamingConventionConfig);
+    /**
+  
+  
+    /**
+    A no-op naming convention: client property names are the server property names. Set it with
+    `NamingConvention.none.setAsDefault()` for a server that already sends the names the client should use.
+    */
+    static none: NamingConvention;
+    /**
+    The "camelCase" naming convention - This implementation only lowercases the first character of the server property name
+    but leaves the rest of the property name intact.  If a more complicated version is needed then one should be created via the ctor.
+    */
+    static camelCase: NamingConvention;
+    /**
+    The default value whenever NamingConventions are not specified: `camelCase`, which suits a .NET
+    server. (2.x defaulted to `none`.)
+    */
+    static defaultInstance: NamingConvention;
+    /**
+    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.
+    ```ts
+    var namingConv = new NamingConvention({
+        serverPropertyNameToClient: function(serverPropertyName) {
+            return serverPropertyName.substr(0, 1).toLowerCase() + serverPropertyName.substr(1);
+        },
+        clientPropertyNameToServer: function(clientPropertyName) {
+            return clientPropertyName.substr(0, 1).toUpperCase() + clientPropertyName.substr(1);
+        }
+    });
+    namingConv.setAsDefault();
+    ```
+    */
+    setAsDefault(): any;
+}

package/metadata/naming-convention.js

@@ -0,0 +1,97 @@
+import { assertConfig } from '../core/assert-param.js';
+import { core, getUuid } from '../core/core.js';
+import { config } from '../config/config.js';
+/**
+A NamingConvention instance is used to specify the naming conventions under which a MetadataStore
+will translate property names between the server and the javascript client.
+
+The default NamingConvention does not perform any translation, it simply passes property names thru unchanged.
+*/
+export class NamingConvention {
+    /** Function that takes a server property name add converts it into a client side property name.  __Read Only__ */
+    serverPropertyNameToClient;
+    /** Function that takes a client property name add converts it into a server side property name. __Read Only__ */
+    clientPropertyNameToServer;
+    /**
+    NamingConvention constructor
+    ```ts
+    // A naming convention that converts the first character of every property name to uppercase on the server
+    // and lowercase on the client.
+    var namingConv = new NamingConvention({
+        serverPropertyNameToClient: function(serverPropertyName) {
+            return serverPropertyName.substr(0, 1).toLowerCase() + serverPropertyName.substr(1);
+        },
+        clientPropertyNameToServer: function(clientPropertyName) {
+            return clientPropertyName.substr(0, 1).toUpperCase() + clientPropertyName.substr(1);
+        }
+    });
+    var ms = new MetadataStore({ namingConvention: namingConv });
+    var em = new EntityManager( { metadataStore: ms });
+    ```
+    */
+    constructor(ncConfig) {
+        assertConfig(ncConfig || {})
+            .whereParam("name").isOptional().isString()
+            .whereParam("serverPropertyNameToClient").isFunction()
+            .whereParam("clientPropertyNameToServer").isFunction()
+            .applyAll(this);
+        if (!this.name) {
+            this.name = getUuid();
+        }
+        config._storeObject(this, "NamingConvention", this.name);
+    }
+    /**
+  
+  
+    /**
+    A no-op naming convention: client property names are the server property names. Set it with
+    `NamingConvention.none.setAsDefault()` for a server that already sends the names the client should use.
+    */
+    static none = new NamingConvention({
+        name: "noChange",
+        serverPropertyNameToClient: (serverPropertyName) => {
+            return serverPropertyName;
+        },
+        clientPropertyNameToServer: (clientPropertyName) => {
+            return clientPropertyName;
+        }
+    });
+    /**
+    The "camelCase" naming convention - This implementation only lowercases the first character of the server property name
+    but leaves the rest of the property name intact.  If a more complicated version is needed then one should be created via the ctor.
+    */
+    static camelCase = new NamingConvention({
+        name: "camelCase",
+        serverPropertyNameToClient: (serverPropertyName) => {
+            return serverPropertyName.substr(0, 1).toLowerCase() + serverPropertyName.substr(1);
+        },
+        clientPropertyNameToServer: (clientPropertyName) => {
+            return clientPropertyName.substr(0, 1).toUpperCase() + clientPropertyName.substr(1);
+        }
+    });
+    /**
+    The default value whenever NamingConventions are not specified: `camelCase`, which suits a .NET
+    server. (2.x defaulted to `none`.)
+    */
+    static defaultInstance = new NamingConvention(NamingConvention.camelCase);
+    /**
+    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.
+    ```ts
+    var namingConv = new NamingConvention({
+        serverPropertyNameToClient: function(serverPropertyName) {
+            return serverPropertyName.substr(0, 1).toLowerCase() + serverPropertyName.substr(1);
+        },
+        clientPropertyNameToServer: function(clientPropertyName) {
+            return clientPropertyName.substr(0, 1).toUpperCase() + clientPropertyName.substr(1);
+        }
+    });
+    namingConv.setAsDefault();
+    ```
+    */
+    setAsDefault() {
+        return core.setAsDefault(this, NamingConvention);
+    }
+}
+NamingConvention.prototype._$typeName = "NamingConvention";
+//# sourceMappingURL=naming-convention.js.map

package/metadata/naming-convention.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"naming-convention.js","sourceRoot":"","sources":["../../src/metadata/naming-convention.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AACvD,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAc7C;;;;;EAKE;AACF,MAAM,OAAO,gBAAgB;IAK3B,kHAAkH;IAClH,0BAA0B,CAAwC;IAClE,iHAAiH;IACjH,0BAA0B,CAAwC;IAElE;;;;;;;;;;;;;;;;MAgBE;IACF,YAAY,QAAgC;QAC1C,YAAY,CAAC,QAAQ,IAAI,EAAE,CAAC;aACvB,UAAU,CAAC,MAAM,CAAC,CAAC,UAAU,EAAE,CAAC,QAAQ,EAAE;aAC1C,UAAU,CAAC,4BAA4B,CAAC,CAAC,UAAU,EAAE;aACrD,UAAU,CAAC,4BAA4B,CAAC,CAAC,UAAU,EAAE;aACrD,QAAQ,CAAC,IAAI,CAAC,CAAC;QACpB,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC;YACf,IAAI,CAAC,IAAI,GAAG,OAAO,EAAE,CAAC;QACxB,CAAC;QACD,MAAM,CAAC,YAAY,CAAC,IAAI,EAAE,kBAAkB,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC;IAC3D,CAAC;IAED;;;;;;MAME;IACF,MAAM,CAAC,IAAI,GAAG,IAAI,gBAAgB,CAAC;QACjC,IAAI,EAAE,UAAU;QAChB,0BAA0B,EAAE,CAAC,kBAAkB,EAAE,EAAE;YACjD,OAAO,kBAAkB,CAAC;QAC5B,CAAC;QACD,0BAA0B,EAAE,CAAC,kBAAkB,EAAE,EAAE;YACjD,OAAO,kBAAkB,CAAC;QAC5B,CAAC;KACF,CAAC,CAAC;IAEH;;;MAGE;IACF,MAAM,CAAC,SAAS,GAAG,IAAI,gBAAgB,CAAC;QACtC,IAAI,EAAE,WAAW;QACjB,0BAA0B,EAAE,CAAC,kBAAkB,EAAE,EAAE;YACjD,OAAO,kBAAkB,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,WAAW,EAAE,GAAG,kBAAkB,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;QACtF,CAAC;QACD,0BAA0B,EAAE,CAAC,kBAAkB,EAAE,EAAE;YACjD,OAAO,kBAAkB,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,WAAW,EAAE,GAAG,kBAAkB,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;QACtF,CAAC;KACF,CAAC,CAAC;IAEH;;;MAGE;IACF,MAAM,CAAC,eAAe,GAAG,IAAI,gBAAgB,CAAC,gBAAgB,CAAC,SAAS,CAAC,CAAC;IAE1E;;;;;;;;;;;;;;MAcE;IACF,YAAY;QACV,OAAO,IAAI,CAAC,YAAY,CAAC,IAAI,EAAE,gBAAgB,CAAC,CAAC;IACnD,CAAC;;AAIH,gBAAgB,CAAC,SAAS,CAAC,UAAU,GAAG,kBAAkB,CAAC","sourcesContent":["import { assertConfig } from '../core/assert-param.js';\r\nimport { core, getUuid } from '../core/core.js';\r\nimport { config } from '../config/config.js';\r\n\r\n// TODO: strongly type context object passed to naming convention converter fns.\r\n\r\n/** Configuration info to be passed to the {@link NamingConvention} constructor */\r\nexport interface NamingConventionConfig {\r\n  /** The name of this NamingConvention */\r\n  name?: string;\r\n  /** Function that takes a server property name add converts it into a client side property name.  */\r\n  serverPropertyNameToClient?: (nm: string, context?: any) => string;\r\n  /** Function that takes a client property name add converts it into a server side property name. */\r\n  clientPropertyNameToServer?: (nm: string, context?: any) => string;\r\n}\r\n\r\n/**\r\nA NamingConvention instance is used to specify the naming conventions under which a MetadataStore\r\nwill translate property names between the server and the javascript client.\r\n\r\nThe default NamingConvention does not perform any translation, it simply passes property names thru unchanged.\r\n*/\r\nexport class NamingConvention {\r\n  /** @hidden @internal */\r\n  declare _$typeName: string;\r\n  /** The name of this NamingConvention. __Read Only__ */\r\n  declare name: string;\r\n  /** Function that takes a server property name add converts it into a client side property name.  __Read Only__ */\r\n  serverPropertyNameToClient: (nm: string, context?: any) => string;\r\n  /** Function that takes a client property name add converts it into a server side property name. __Read Only__ */\r\n  clientPropertyNameToServer: (nm: string, context?: any) => string;\r\n\r\n  /**\r\n  NamingConvention constructor\r\n  ```ts\r\n  // A naming convention that converts the first character of every property name to uppercase on the server\r\n  // and lowercase on the client.\r\n  var namingConv = new NamingConvention({\r\n      serverPropertyNameToClient: function(serverPropertyName) {\r\n          return serverPropertyName.substr(0, 1).toLowerCase() + serverPropertyName.substr(1);\r\n      },\r\n      clientPropertyNameToServer: function(clientPropertyName) {\r\n          return clientPropertyName.substr(0, 1).toUpperCase() + clientPropertyName.substr(1);\r\n      }            \r\n  });\r\n  var ms = new MetadataStore({ namingConvention: namingConv });\r\n  var em = new EntityManager( { metadataStore: ms });\r\n  ```\r\n  */\r\n  constructor(ncConfig: NamingConventionConfig ) {\r\n    assertConfig(ncConfig || {})\r\n        .whereParam(\"name\").isOptional().isString()\r\n        .whereParam(\"serverPropertyNameToClient\").isFunction()\r\n        .whereParam(\"clientPropertyNameToServer\").isFunction()\r\n        .applyAll(this);\r\n    if (!this.name) {\r\n      this.name = getUuid();\r\n    }\r\n    config._storeObject(this, \"NamingConvention\", this.name);\r\n  }\r\n\r\n  /**\r\n\r\n\r\n  /**\r\n  A no-op naming convention: client property names are the server property names. Set it with\r\n  `NamingConvention.none.setAsDefault()` for a server that already sends the names the client should use.\r\n  */\r\n  static none = new NamingConvention({\r\n    name: \"noChange\",\r\n    serverPropertyNameToClient: (serverPropertyName) => {\r\n      return serverPropertyName;\r\n    },\r\n    clientPropertyNameToServer: (clientPropertyName) => {\r\n      return clientPropertyName;\r\n    }\r\n  });\r\n\r\n  /**\r\n  The \"camelCase\" naming convention - This implementation only lowercases the first character of the server property name\r\n  but leaves the rest of the property name intact.  If a more complicated version is needed then one should be created via the ctor.\r\n  */\r\n  static camelCase = new NamingConvention({\r\n    name: \"camelCase\",\r\n    serverPropertyNameToClient: (serverPropertyName) => {\r\n      return serverPropertyName.substr(0, 1).toLowerCase() + serverPropertyName.substr(1);\r\n    },\r\n    clientPropertyNameToServer: (clientPropertyName) => {\r\n      return clientPropertyName.substr(0, 1).toUpperCase() + clientPropertyName.substr(1);\r\n    }\r\n  });\r\n\r\n  /**\r\n  The default value whenever NamingConventions are not specified: `camelCase`, which suits a .NET\r\n  server. (2.x defaulted to `none`.)\r\n  */\r\n  static defaultInstance = new NamingConvention(NamingConvention.camelCase);\r\n\r\n  /**\r\n  Sets the 'defaultInstance' by creating a copy of the current 'defaultInstance' and then applying all of the properties of the current instance.\r\n  The current instance is returned unchanged.\r\n  ```ts\r\n  var namingConv = new NamingConvention({\r\n      serverPropertyNameToClient: function(serverPropertyName) {\r\n          return serverPropertyName.substr(0, 1).toLowerCase() + serverPropertyName.substr(1);\r\n      },\r\n      clientPropertyNameToServer: function(clientPropertyName) {\r\n          return clientPropertyName.substr(0, 1).toUpperCase() + clientPropertyName.substr(1);\r\n      }            \r\n  });\r\n  namingConv.setAsDefault();\r\n  ```\r\n  */\r\n  setAsDefault() {\r\n    return core.setAsDefault(this, NamingConvention);\r\n  }\r\n\r\n}\r\n\r\nNamingConvention.prototype._$typeName = \"NamingConvention\";\r\n\r\n\r\n\r\n\r\n"]}

package/mixins/mixin-get-entity-graph.d.ts

@@ -0,0 +1,63 @@
+import { Entity, EntityManager, EntityQuery, ExpandClause } from '../breeze.js';
+/**
+ * An {@link EntityManager} with `getEntityGraph`, which returns entities together with everything
+ * an expand path reaches from them in the cache, including deleted entities. Importing
+ * `breeze-client/mixin-get-entity-graph` adds the method to every manager, but changes the
+ * prototype rather than the `EntityManager` type, so cast to this type to call it:
+ *
+ * ```ts
+ * import 'breeze-client/mixin-get-entity-graph';
+ * import type { HasEntityGraph } from 'breeze-client/mixin-get-entity-graph';
+ *
+ * const graph = (em as HasEntityGraph).getEntityGraph(customer, 'orders.orderDetails');
+ * ```
+ */
+export interface HasEntityGraph extends EntityManager {
+    /**
+    Get related entities of root entity (or root entities) as specified by expand.
+    @example
+        const graph = (em as HasEntityGraph).getEntityGraph(customer, 'orders.orderDetails');
+        // the customer, all of its orders, and their details - including deleted ones
+    @param roots {Entity|Array of Entity} The root entity or root entities.
+    @param expand {String|Array of String|Object} an expand string, a query expand clause, or array of string paths
+    @returns {Array of Entity} root entities and their related entities, including deleted entities. Duplicates are removed and entity order is indeterminate.
+    */
+    getEntityGraph(roots: Entity | Array<Entity>, expand: string | Array<string> | ExpandClause): Array<Entity>;
+    /**
+    Execute query locally and return both the query results and their related entities as specified by the optional expand parameter or the query's expand clause.
+    @example
+        const query = EntityQuery.from(Customer)
+          .where('companyName', 'startsWith', 'Alfred')
+          .expand('orders.orderDetails');
+        const graph = (em as HasEntityGraph).getEntityGraph(query);
+        // the 'Alfred' customers, their orders, and their details - including deleted ones
+    @param query {EntityQuery} A query to be executed against the manager's local cache.
+    @param [expand] {String|Array of String|Object} an expand string, a query expand clause, or array of string paths
+    @returns {Array of Entity} local queried root entities and their related entities, including deleted entities. Duplicates are removed and entity order is indeterminate.
+    */
+    getEntityGraph(query: EntityQuery, expand?: string | Array<string> | ExpandClause): Array<Entity>;
+}
+/**
+ * Adds `getEntityGraph` to `EntityManager.prototype`.
+ *
+ * Importing this module calls it, so an application only needs the import:
+ *
+ * ```ts
+ * import 'breeze-client/mixin-get-entity-graph';
+ * import type { HasEntityGraph } from 'breeze-client/mixin-get-entity-graph';
+ *
+ * const graph = (em as HasEntityGraph).getEntityGraph(customer, 'orders.orderDetails');
+ * ```
+ *
+ * Calling it yourself is for a bundler aggressive enough to drop a module imported only for its
+ * effect. This is the one module in the package that `sideEffects` in package.json names for
+ * that reason.
+ *
+ * @param emclass - Accepted for backwards compatibility and not used: the method always goes on
+ *   `EntityManager.prototype`. Adding it twice is a no-op.
+ *
+ * @see {@link HasEntityGraph} for the method it adds.
+ */
+export declare function mixinEntityGraph(emclass: {
+    new (): EntityManager;
+}): void;