grunt-breezets - npm Package Compare versions

Comparing version 0.1.14 to 0.1.178

Gruntfile.js

@@ -43,3 +43,3 @@ /*
                     //outdir: path.resolve("."),
-                    breezeinfoFile: path.resolve("source", "Breeze reference", "plans.breezeinfo")
+                    breezeinfoFile: path.resolve("test", "plans.breezeinfo")
                 }
@@ -46,0 +46,0 @@ },

package.json

 {
     "name": "grunt-breezets",
     "description": "grunt-breezets",
-    "version": "0.1.14",
+    "version": "0.1.178",
     "homepage": "https://github.com/tschaumburg/breezets",
@@ -42,4 +42,5 @@ "author": {
     "dependencies": {
+        "@types/grunt": "^0.4.21",
         "breeze-client": "^1.6.3",
-        "breezets": "^0.1.9",
+        "breezets": "^0.1.17",
         "replace-ext": "^1.0.0",
@@ -46,0 +47,0 @@ "xml2js": "^0.4.17"

source/Breeze reference/index.ts

@@ -1,1 +0,1 @@
-export * from "./typedefs";
export * from "./myservice";
export * from "./querybuilder";
+export * from "./typedefs";
export * from "./plansmanager";
export * from "./querybuilder";

source/grunt_breezets.ts

@@ -10,3 +10,2 @@ /*
 'use strict';
-var breezets = require('breezets');
 var fs = require('fs');
@@ -16,4 +15,6 @@ var path = require('path');
 
+import * as breezets from 'breezets';
 import * as btoptions from "./options";
-module.exports = function (grunt)
+import * as gruntns from "grunt";
+module.exports = function (grunt: any)
 {
@@ -31,10 +32,9 @@ grunt.registerMultiTask('breezets', 'Task converting', function ()
         grunt.log.writeln('outdir: %s', options.outdir);
-        grunt.log.writeln('servicename: %s', options.servicename);
         grunt.log.writeln('serviceurl: %s', options.serviceurl);
-        grunt.log.writeln('namespace: %s', options.namespace);
         grunt.log.writeln('proxyname: %s', options.proxyname);
-        grunt.log.writeln('typedqueries: %s', options.typedqueries);
-        grunt.log.writeln('extensions: %s', options.extensions);
 
-        impl.callGenerate(grunt, options.outdir, options.metadataurlValue, options.metadata, options.servicename, options.serviceurl, options.namespace, options.proxyname, options.typedqueries, options.extensions);
+        var metadata = impl.callGenerate(grunt, options.outdir, options.metadataurlValue, options.metadata, options.serviceurl, options.proxyname);
+
+        if (!!options.metadataCache && !!metadata)
+            grunt.file.write(options.metadataCache, metadata);
     });
@@ -49,6 +49,13 @@
 {
-    export function callGenerate(grunt, outdir, metadataUrl, cachedMetadata, servicename, serviceurl, namespace, proxyname, typedqueries, extensions)
+    export function callGenerate(
+        grunt: any,
+        outdir: string,
+        metadataUrl: string,
+        cachedMetadata: string,
+        serviceurl: string,
+        proxyname: string
+    ): string
     {
         var metadata = breezets.getMetadata(metadataUrl, cachedMetadata);
-        var files = breezets.generateTypescript(servicename, metadata, serviceurl, namespace, proxyname, typedqueries, extensions, [{ key: "flavor", value: "mmm...chocolate" }]);
+        var files = breezets.generateTypescript(metadata, serviceurl, proxyname, [{ key: "flavor", value: "mmm...chocolate" }]);
 
@@ -64,3 +71,5 @@ for (var n = 0; n < files.length; n++)
         }
+
+        return metadata;
     }
 }

source/options.ts

@@ -13,8 +13,4 @@ var path = require('path');
     outdir?: string = null;
-    servicename?: string = null;
     serviceurl?: string = null;
     proxyname?: string = null;
-    extensions?: string = null;
-    namespace?: string = null;
-    typedqueries?: string = null;
 };
@@ -26,4 +22,2 @@
     {
-        extensions: 'true',
-        typedqueries: 'true',
     };
@@ -33,3 +27,3 @@ return options;
 
-function breezeinfoOptions(grunt, breezeinfoFile: string): IBreezetsOptions
+function breezeinfoOptions(grunt: any, breezeinfoFile: string): IBreezetsOptions
 {
@@ -42,14 +36,26 @@ var breezeinfo: IBreezetsOptions = {};
             var breezeinfoText = grunt.file.read(breezeinfoFile);
-            xml2js.parseString(breezeinfoText, function (err, result) {
+            xml2js.parseString(breezeinfoText, function (err: any, result: any) {
                 grunt.log.writeln("result = " + JSON.stringify(result));
                 grunt.log.writeln("err = " + JSON.stringify(err));
-                breezeinfo.metadataurlValue = result && result.BreezeService && result.BreezeService.MetadataUrl && result.BreezeService.MetadataUrl[0];
+
+                // <MetadataUrl cachefile="./plans.metadata">
+                //   http://localhost:58659//api/plans/metadata
+                // </MetadataUrl>
+                var metadataElement = result && result.BreezeService && result.BreezeService.MetadataUrl && result.BreezeService.MetadataUrl[0];
+                breezeinfo.metadataurlValue = metadataElement && metadataElement._ && metadataElement._.toString().trim();
+                var metadataAttribs = metadataElement && metadataElement.$;
+                var cachefile = metadataAttribs && metadataAttribs.cachefile;
+                breezeinfo.metadataCache = cachefile && path.join(getDir(grunt, breezeinfoFile), cachefile);
+
+                grunt.log.writeln("metadataElement = " + JSON.stringify(metadataElement));
+                grunt.log.writeln("metadataAttribs = " + JSON.stringify(metadataAttribs));
+
+                // <Output>
+                //   <Typescript outdir="." framework="angular" extension=".d.ts" proxyname="PlansManager" generateTypedQueries="true"/>
+                // </Output>
                 var output = result && result.BreezeService && result.BreezeService.Output && result.BreezeService.Output[0]
                 var attribs = output && output.Typescript && output.Typescript[0] && output.Typescript[0].$
-                breezeinfo.servicename = null;//attribs && attribs.;
                 breezeinfo.serviceurl = null;//attribs && attribs.;
                 breezeinfo.proxyname = attribs && attribs.proxyname;
-                breezeinfo.extensions = attribs && attribs.extension;
-                breezeinfo.namespace = attribs && attribs.namespace;
-                breezeinfo.typedqueries = attribs && attribs.generateTypedQueries;
+
                 grunt.log.writeln("breezeinfo = " + JSON.stringify(breezeinfo));
@@ -73,9 +79,5 @@ });
             metadata: primaryOptions.metadata || secondaryOptions.metadata || defaultOptions.metadata,
-            servicename: primaryOptions.servicename || secondaryOptions.servicename || defaultOptions.servicename,
             outdir: primaryOptions.outdir || secondaryOptions.outdir || defaultOptions.outdir,
             serviceurl: primaryOptions.serviceurl || secondaryOptions.serviceurl || defaultOptions.serviceurl,
             proxyname: primaryOptions.proxyname || secondaryOptions.proxyname || defaultOptions.proxyname,
-            extensions: primaryOptions.extensions || secondaryOptions.extensions || defaultOptions.extensions,//'true',
-            namespace: primaryOptions.namespace || secondaryOptions.namespace || defaultOptions.namespace,
-            typedqueries: primaryOptions.typedqueries || secondaryOptions.typedqueries  || defaultOptions.typedqueries,//|| 'true',
         };
@@ -85,3 +87,3 @@ return result;
 
-function GetMetadata(grunt, url: string, cachefile: string, verbatim: string): string
+function GetMetadata(grunt: any, url: string, cachefile: string, verbatim: string): string
 {
@@ -92,3 +94,4 @@ if (!!verbatim)
     if (!!cachefile)
-        return grunt.file.read(cachefile);
+        if (grunt.file.isFile(cachefile))
+            return grunt.file.read(cachefile);
 
@@ -101,3 +104,3 @@ if (!!url)
 
-function getDir(grunt, fileordir: string): string
+function getDir(grunt: any, fileordir: string): string
 {
@@ -121,3 +124,3 @@ if (fileordir==="")
 
-export function getOptions(grunt, task): IBreezetsOptions
+export function getOptions(grunt: any, task: any): IBreezetsOptions
 {
@@ -124,0 +127,0 @@ // Merge task-specific and/or target-specific options with these defaults.

tasks/Breeze reference/index.d.ts

 export * from "./typedefs";
-export * from "./myservice";
+export * from "./plansmanager";
 export * from "./querybuilder";

tasks/Breeze reference/index.js

@@ -6,4 +6,4 @@ "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-__export(require("./myservice"));
+__export(require("./plansmanager"));
 __export(require("./querybuilder"));
 //# sourceMappingURL=index.js.map

tasks/grunt_breezets.js

@@ -10,6 +10,6 @@ /*
 Object.defineProperty(exports, "__esModule", { value: true });
-var breezets = require('breezets');
 var fs = require('fs');
 var path = require('path');
 var xml2js = require('xml2js');
+const breezets = require("breezets");
 const btoptions = require("./options");
@@ -25,9 +25,7 @@ module.exports = function (grunt) {
         grunt.log.writeln('outdir: %s', options.outdir);
-        grunt.log.writeln('servicename: %s', options.servicename);
         grunt.log.writeln('serviceurl: %s', options.serviceurl);
-        grunt.log.writeln('namespace: %s', options.namespace);
         grunt.log.writeln('proxyname: %s', options.proxyname);
-        grunt.log.writeln('typedqueries: %s', options.typedqueries);
-        grunt.log.writeln('extensions: %s', options.extensions);
-        impl.callGenerate(grunt, options.outdir, options.metadataurlValue, options.metadata, options.servicename, options.serviceurl, options.namespace, options.proxyname, options.typedqueries, options.extensions);
+        var metadata = impl.callGenerate(grunt, options.outdir, options.metadataurlValue, options.metadata, options.serviceurl, options.proxyname);
+        if (!!options.metadataCache && !!metadata)
+            grunt.file.write(options.metadataCache, metadata);
     });
@@ -40,5 +38,5 @@ grunt.task.registerMultiTask('dolog', 'Log stuff.', function () {
 (function (impl) {
-    function callGenerate(grunt, outdir, metadataUrl, cachedMetadata, servicename, serviceurl, namespace, proxyname, typedqueries, extensions) {
+    function callGenerate(grunt, outdir, metadataUrl, cachedMetadata, serviceurl, proxyname) {
         var metadata = breezets.getMetadata(metadataUrl, cachedMetadata);
-        var files = breezets.generateTypescript(servicename, metadata, serviceurl, namespace, proxyname, typedqueries, extensions, [{ key: "flavor", value: "mmm...chocolate" }]);
+        var files = breezets.generateTypescript(metadata, serviceurl, proxyname, [{ key: "flavor", value: "mmm...chocolate" }]);
         for (var n = 0; n < files.length; n++) {
@@ -52,2 +50,3 @@ var filename = files[n].filename;
         }
+        return metadata;
     }
@@ -54,0 +53,0 @@ impl.callGenerate = callGenerate;

tasks/options.d.ts

@@ -7,9 +7,5 @@ export declare class IBreezetsOptions {
     outdir?: string;
-    servicename?: string;
     serviceurl?: string;
     proxyname?: string;
-    extensions?: string;
-    namespace?: string;
-    typedqueries?: string;
 }
 export declare function getOptions(grunt: any, task: any): IBreezetsOptions;

tasks/options.js

@@ -14,8 +14,4 @@ "use strict";
         this.outdir = null;
-        this.servicename = null;
         this.serviceurl = null;
         this.proxyname = null;
-        this.extensions = null;
-        this.namespace = null;
-        this.typedqueries = null;
     }
@@ -26,6 +22,3 @@ }
 function defaultOptions() {
-    var options = {
-        extensions: 'true',
-        typedqueries: 'true',
-    };
+    var options = {};
     return options;
@@ -41,11 +34,19 @@ }
                 grunt.log.writeln("err = " + JSON.stringify(err));
-                breezeinfo.metadataurlValue = result && result.BreezeService && result.BreezeService.MetadataUrl && result.BreezeService.MetadataUrl[0];
+                // <MetadataUrl cachefile="./plans.metadata">
+                //   http://localhost:58659//api/plans/metadata
+                // </MetadataUrl>
+                var metadataElement = result && result.BreezeService && result.BreezeService.MetadataUrl && result.BreezeService.MetadataUrl[0];
+                breezeinfo.metadataurlValue = metadataElement && metadataElement._ && metadataElement._.toString().trim();
+                var metadataAttribs = metadataElement && metadataElement.$;
+                var cachefile = metadataAttribs && metadataAttribs.cachefile;
+                breezeinfo.metadataCache = cachefile && path.join(getDir(grunt, breezeinfoFile), cachefile);
+                grunt.log.writeln("metadataElement = " + JSON.stringify(metadataElement));
+                grunt.log.writeln("metadataAttribs = " + JSON.stringify(metadataAttribs));
+                // <Output>
+                //   <Typescript outdir="." framework="angular" extension=".d.ts" proxyname="PlansManager" generateTypedQueries="true"/>
+                // </Output>
                 var output = result && result.BreezeService && result.BreezeService.Output && result.BreezeService.Output[0];
                 var attribs = output && output.Typescript && output.Typescript[0] && output.Typescript[0].$;
-                breezeinfo.servicename = null; //attribs && attribs.;
                 breezeinfo.serviceurl = null; //attribs && attribs.;
                 breezeinfo.proxyname = attribs && attribs.proxyname;
-                breezeinfo.extensions = attribs && attribs.extension;
-                breezeinfo.namespace = attribs && attribs.namespace;
-                breezeinfo.typedqueries = attribs && attribs.generateTypedQueries;
                 grunt.log.writeln("breezeinfo = " + JSON.stringify(breezeinfo));
@@ -66,9 +67,5 @@ });
         metadata: primaryOptions.metadata || secondaryOptions.metadata || defaultOptions.metadata,
-        servicename: primaryOptions.servicename || secondaryOptions.servicename || defaultOptions.servicename,
         outdir: primaryOptions.outdir || secondaryOptions.outdir || defaultOptions.outdir,
         serviceurl: primaryOptions.serviceurl || secondaryOptions.serviceurl || defaultOptions.serviceurl,
         proxyname: primaryOptions.proxyname || secondaryOptions.proxyname || defaultOptions.proxyname,
-        extensions: primaryOptions.extensions || secondaryOptions.extensions || defaultOptions.extensions,
-        namespace: primaryOptions.namespace || secondaryOptions.namespace || defaultOptions.namespace,
-        typedqueries: primaryOptions.typedqueries || secondaryOptions.typedqueries || defaultOptions.typedqueries,
     };
@@ -81,3 +78,4 @@ return result;
     if (!!cachefile)
-        return grunt.file.read(cachefile);
+        if (grunt.file.isFile(cachefile))
+            return grunt.file.read(cachefile);
     if (!!url)
@@ -84,0 +82,0 @@ return breezets.getMetadata(url, null);

test/index.ts

@@ -1,1 +0,1 @@
-export * from "./typedefs";
export * from "./myservice";
export * from "./querybuilder";
+export * from "./typedefs";
export * from "./plansmanager";
export * from "./querybuilder";

test/querybuilder.ts

@@ -1,1 +0,1 @@
-namespace superdup.server.querybuilder
{
   import extensions = require("breezets");
   import typedefs = require("./typedefs");

   export class BoardQuery
   {
      private static _instance: BoardQuery = null;
      static get _Instance(): BoardQuery {
          if (BoardQuery._instance == null)
              BoardQuery._instance = new BoardQuery();
          return BoardQuery._instance;
      }
      public Id: extensions.NumberFieldInfo<BoardQuery, typedefs.Board> = new extensions.NumberFieldInfo<BoardQuery, typedefs.Board>(BoardQuery._instance, "Id"); 
      public Guid: extensions.StringFieldInfo<BoardQuery, typedefs.Board> = new extensions.StringFieldInfo<BoardQuery, typedefs.Board>(BoardQuery._instance, "Guid"); 
      public Code: extensions.StringFieldInfo<BoardQuery, typedefs.Board> = new extensions.StringFieldInfo<BoardQuery, typedefs.Board>(BoardQuery._instance, "Code"); 
      public BoardSeriesId: extensions.NumberFieldInfo<BoardQuery, typedefs.Board> = new extensions.NumberFieldInfo<BoardQuery, typedefs.Board>(BoardQuery._instance, "BoardSeriesId"); 
      public CardDistribution: extensions.StringFieldInfo<BoardQuery, typedefs.Board> = new extensions.StringFieldInfo<BoardQuery, typedefs.Board>(BoardQuery._instance, "CardDistribution"); 
      public BoardSeries: extensions.SingleAssociationFieldInfo<BoardQuery, typedefs.Board, BoardSeriesQuery, typedefs.BoardSeries> = new extensions.SingleAssociationFieldInfo<BoardQuery, typedefs.Board, BoardSeriesQuery, typedefs.BoardSeries>(BoardQuery._Instance, "BoardSeries");
      public Scores: extensions.MultiAssociationFieldInfo<BoardQuery, typedefs.Board, BoardScoreQuery, typedefs.BoardScore> = new extensions.MultiAssociationFieldInfo<BoardQuery, typedefs.Board, BoardScoreQuery, typedefs.BoardScore>(BoardQuery._Instance, "Scores", BoardScoreQuery._Instance);
   }

   export class BoardSeriesQuery
   {
      private static _instance: BoardSeriesQuery = null;
      static get _Instance(): BoardSeriesQuery {
          if (BoardSeriesQuery._instance == null)
              BoardSeriesQuery._instance = new BoardSeriesQuery();
          return BoardSeriesQuery._instance;
      }
      public Id: extensions.NumberFieldInfo<BoardSeriesQuery, typedefs.BoardSeries> = new extensions.NumberFieldInfo<BoardSeriesQuery, typedefs.BoardSeries>(BoardSeriesQuery._instance, "Id"); 
      public Guid: extensions.StringFieldInfo<BoardSeriesQuery, typedefs.BoardSeries> = new extensions.StringFieldInfo<BoardSeriesQuery, typedefs.BoardSeries>(BoardSeriesQuery._instance, "Guid"); 
      public Code: extensions.StringFieldInfo<BoardSeriesQuery, typedefs.BoardSeries> = new extensions.StringFieldInfo<BoardSeriesQuery, typedefs.BoardSeries>(BoardSeriesQuery._instance, "Code"); 
      public Name: extensions.StringFieldInfo<BoardSeriesQuery, typedefs.BoardSeries> = new extensions.StringFieldInfo<BoardSeriesQuery, typedefs.BoardSeries>(BoardSeriesQuery._instance, "Name"); 
      public Description: extensions.StringFieldInfo<BoardSeriesQuery, typedefs.BoardSeries> = new extensions.StringFieldInfo<BoardSeriesQuery, typedefs.BoardSeries>(BoardSeriesQuery._instance, "Description"); 
      public Boards: extensions.MultiAssociationFieldInfo<BoardSeriesQuery, typedefs.BoardSeries, BoardQuery, typedefs.Board> = new extensions.MultiAssociationFieldInfo<BoardSeriesQuery, typedefs.BoardSeries, BoardQuery, typedefs.Board>(BoardSeriesQuery._Instance, "Boards", BoardQuery._Instance);
   }

   export class BoardScoreQuery
   {
      private static _instance: BoardScoreQuery = null;
      static get _Instance(): BoardScoreQuery {
          if (BoardScoreQuery._instance == null)
              BoardScoreQuery._instance = new BoardScoreQuery();
          return BoardScoreQuery._instance;
      }
      public Id: extensions.NumberFieldInfo<BoardScoreQuery, typedefs.BoardScore> = new extensions.NumberFieldInfo<BoardScoreQuery, typedefs.BoardScore>(BoardScoreQuery._instance, "Id"); 
      public BoardId: extensions.NumberFieldInfo<BoardScoreQuery, typedefs.BoardScore> = new extensions.NumberFieldInfo<BoardScoreQuery, typedefs.BoardScore>(BoardScoreQuery._instance, "BoardId"); 
      public Score: extensions.NumberFieldInfo<BoardScoreQuery, typedefs.BoardScore> = new extensions.NumberFieldInfo<BoardScoreQuery, typedefs.BoardScore>(BoardScoreQuery._instance, "Score"); 
      public Count: extensions.NumberFieldInfo<BoardScoreQuery, typedefs.BoardScore> = new extensions.NumberFieldInfo<BoardScoreQuery, typedefs.BoardScore>(BoardScoreQuery._instance, "Count"); 
      public Board: extensions.SingleAssociationFieldInfo<BoardScoreQuery, typedefs.BoardScore, BoardQuery, typedefs.Board> = new extensions.SingleAssociationFieldInfo<BoardScoreQuery, typedefs.BoardScore, BoardQuery, typedefs.Board>(BoardScoreQuery._Instance, "Board");
   }


}
+   import extensions = require("breezets");
   import typedefs = require("./typedefs");

   export class EventQuery
   {
      private static _instance: EventQuery = null;
      static get _Instance(): EventQuery {
          if (EventQuery._instance == null)
              EventQuery._instance = new EventQuery();
          return EventQuery._instance;
      }
      public Id: extensions.NumberFieldInfo<EventQuery, typedefs.Event> = new extensions.NumberFieldInfo<EventQuery, typedefs.Event>(EventQuery._instance, "Id"); 
      public EventName: extensions.StringFieldInfo<EventQuery, typedefs.Event> = new extensions.StringFieldInfo<EventQuery, typedefs.Event>(EventQuery._instance, "EventName"); 
      public EventTime: extensions.DateFieldInfo<EventQuery, typedefs.Event> = new extensions.DateFieldInfo<EventQuery, typedefs.Event>(EventQuery._instance, "EventTime"); 
      public EventLocation: extensions.StringFieldInfo<EventQuery, typedefs.Event> = new extensions.StringFieldInfo<EventQuery, typedefs.Event>(EventQuery._instance, "EventLocation"); 
      public AccountId: extensions.NumberFieldInfo<EventQuery, typedefs.Event> = new extensions.NumberFieldInfo<EventQuery, typedefs.Event>(EventQuery._instance, "AccountId"); 
      public BoardSets: extensions.MultiAssociationFieldInfo<EventQuery, typedefs.Event, BoardSetQuery, typedefs.BoardSet> = new extensions.MultiAssociationFieldInfo<EventQuery, typedefs.Event, BoardSetQuery, typedefs.BoardSet>(EventQuery._Instance, "BoardSets", BoardSetQuery._Instance);
      public Pairs: extensions.MultiAssociationFieldInfo<EventQuery, typedefs.Event, PairQuery, typedefs.Pair> = new extensions.MultiAssociationFieldInfo<EventQuery, typedefs.Event, PairQuery, typedefs.Pair>(EventQuery._Instance, "Pairs", PairQuery._Instance);
      public Players: extensions.MultiAssociationFieldInfo<EventQuery, typedefs.Event, PlayerQuery, typedefs.Player> = new extensions.MultiAssociationFieldInfo<EventQuery, typedefs.Event, PlayerQuery, typedefs.Player>(EventQuery._Instance, "Players", PlayerQuery._Instance);
      public Rounds: extensions.MultiAssociationFieldInfo<EventQuery, typedefs.Event, RoundQuery, typedefs.Round> = new extensions.MultiAssociationFieldInfo<EventQuery, typedefs.Event, RoundQuery, typedefs.Round>(EventQuery._Instance, "Rounds", RoundQuery._Instance);
      public Tables: extensions.MultiAssociationFieldInfo<EventQuery, typedefs.Event, TableQuery, typedefs.Table> = new extensions.MultiAssociationFieldInfo<EventQuery, typedefs.Event, TableQuery, typedefs.Table>(EventQuery._Instance, "Tables", TableQuery._Instance);
   }

   export class BoardSetQuery
   {
      private static _instance: BoardSetQuery = null;
      static get _Instance(): BoardSetQuery {
          if (BoardSetQuery._instance == null)
              BoardSetQuery._instance = new BoardSetQuery();
          return BoardSetQuery._instance;
      }
      public Id: extensions.NumberFieldInfo<BoardSetQuery, typedefs.BoardSet> = new extensions.NumberFieldInfo<BoardSetQuery, typedefs.BoardSet>(BoardSetQuery._instance, "Id"); 
      public Name: extensions.StringFieldInfo<BoardSetQuery, typedefs.BoardSet> = new extensions.StringFieldInfo<BoardSetQuery, typedefs.BoardSet>(BoardSetQuery._instance, "Name"); 
      public EventId: extensions.NumberFieldInfo<BoardSetQuery, typedefs.BoardSet> = new extensions.NumberFieldInfo<BoardSetQuery, typedefs.BoardSet>(BoardSetQuery._instance, "EventId"); 
      public BoardRefs: extensions.MultiAssociationFieldInfo<BoardSetQuery, typedefs.BoardSet, BoardRefQuery, typedefs.BoardRef> = new extensions.MultiAssociationFieldInfo<BoardSetQuery, typedefs.BoardSet, BoardRefQuery, typedefs.BoardRef>(BoardSetQuery._Instance, "BoardRefs", BoardRefQuery._Instance);
      public Event: extensions.SingleAssociationFieldInfo<BoardSetQuery, typedefs.BoardSet, EventQuery, typedefs.Event> = new extensions.SingleAssociationFieldInfo<BoardSetQuery, typedefs.BoardSet, EventQuery, typedefs.Event>(BoardSetQuery._Instance, "Event");
   }

   export class BoardRefQuery
   {
      private static _instance: BoardRefQuery = null;
      static get _Instance(): BoardRefQuery {
          if (BoardRefQuery._instance == null)
              BoardRefQuery._instance = new BoardRefQuery();
          return BoardRefQuery._instance;
      }
      public Id: extensions.NumberFieldInfo<BoardRefQuery, typedefs.BoardRef> = new extensions.NumberFieldInfo<BoardRefQuery, typedefs.BoardRef>(BoardRefQuery._instance, "Id"); 
      public BoardRefNo: extensions.NumberFieldInfo<BoardRefQuery, typedefs.BoardRef> = new extensions.NumberFieldInfo<BoardRefQuery, typedefs.BoardRef>(BoardRefQuery._instance, "BoardRefNo"); 
      public BoardGuid: extensions.StringFieldInfo<BoardRefQuery, typedefs.BoardRef> = new extensions.StringFieldInfo<BoardRefQuery, typedefs.BoardRef>(BoardRefQuery._instance, "BoardGuid"); 
      public BoardSetId: extensions.NumberFieldInfo<BoardRefQuery, typedefs.BoardRef> = new extensions.NumberFieldInfo<BoardRefQuery, typedefs.BoardRef>(BoardRefQuery._instance, "BoardSetId"); 
      public BoardSet: extensions.SingleAssociationFieldInfo<BoardRefQuery, typedefs.BoardRef, BoardSetQuery, typedefs.BoardSet> = new extensions.SingleAssociationFieldInfo<BoardRefQuery, typedefs.BoardRef, BoardSetQuery, typedefs.BoardSet>(BoardRefQuery._Instance, "BoardSet");
      public Plan: extensions.MultiAssociationFieldInfo<BoardRefQuery, typedefs.BoardRef, BoardAllocationQuery, typedefs.BoardAllocation> = new extensions.MultiAssociationFieldInfo<BoardRefQuery, typedefs.BoardRef, BoardAllocationQuery, typedefs.BoardAllocation>(BoardRefQuery._Instance, "Plan", BoardAllocationQuery._Instance);
   }

   export class BoardAllocationQuery
   {
      private static _instance: BoardAllocationQuery = null;
      static get _Instance(): BoardAllocationQuery {
          if (BoardAllocationQuery._instance == null)
              BoardAllocationQuery._instance = new BoardAllocationQuery();
          return BoardAllocationQuery._instance;
      }
      public Id: extensions.NumberFieldInfo<BoardAllocationQuery, typedefs.BoardAllocation> = new extensions.NumberFieldInfo<BoardAllocationQuery, typedefs.BoardAllocation>(BoardAllocationQuery._instance, "Id"); 
      public DealId: extensions.NumberFieldInfo<BoardAllocationQuery, typedefs.BoardAllocation> = new extensions.NumberFieldInfo<BoardAllocationQuery, typedefs.BoardAllocation>(BoardAllocationQuery._instance, "DealId"); 
      public TableId: extensions.NumberFieldInfo<BoardAllocationQuery, typedefs.BoardAllocation> = new extensions.NumberFieldInfo<BoardAllocationQuery, typedefs.BoardAllocation>(BoardAllocationQuery._instance, "TableId"); 
      public BoardRefId: extensions.NumberFieldInfo<BoardAllocationQuery, typedefs.BoardAllocation> = new extensions.NumberFieldInfo<BoardAllocationQuery, typedefs.BoardAllocation>(BoardAllocationQuery._instance, "BoardRefId"); 
      public NSScore: extensions.NumberFieldInfo<BoardAllocationQuery, typedefs.BoardAllocation> = new extensions.NumberFieldInfo<BoardAllocationQuery, typedefs.BoardAllocation>(BoardAllocationQuery._instance, "NSScore"); 
      public EWScore: extensions.NumberFieldInfo<BoardAllocationQuery, typedefs.BoardAllocation> = new extensions.NumberFieldInfo<BoardAllocationQuery, typedefs.BoardAllocation>(BoardAllocationQuery._instance, "EWScore"); 
      public BoardRef: extensions.SingleAssociationFieldInfo<BoardAllocationQuery, typedefs.BoardAllocation, BoardRefQuery, typedefs.BoardRef> = new extensions.SingleAssociationFieldInfo<BoardAllocationQuery, typedefs.BoardAllocation, BoardRefQuery, typedefs.BoardRef>(BoardAllocationQuery._Instance, "BoardRef");
      public Deal: extensions.SingleAssociationFieldInfo<BoardAllocationQuery, typedefs.BoardAllocation, DealQuery, typedefs.Deal> = new extensions.SingleAssociationFieldInfo<BoardAllocationQuery, typedefs.BoardAllocation, DealQuery, typedefs.Deal>(BoardAllocationQuery._Instance, "Deal");
      public Table: extensions.SingleAssociationFieldInfo<BoardAllocationQuery, typedefs.BoardAllocation, TableQuery, typedefs.Table> = new extensions.SingleAssociationFieldInfo<BoardAllocationQuery, typedefs.BoardAllocation, TableQuery, typedefs.Table>(BoardAllocationQuery._Instance, "Table");
   }

   export class DealQuery
   {
      private static _instance: DealQuery = null;
      static get _Instance(): DealQuery {
          if (DealQuery._instance == null)
              DealQuery._instance = new DealQuery();
          return DealQuery._instance;
      }
      public Id: extensions.NumberFieldInfo<DealQuery, typedefs.Deal> = new extensions.NumberFieldInfo<DealQuery, typedefs.Deal>(DealQuery._instance, "Id"); 
      public DealNo: extensions.NumberFieldInfo<DealQuery, typedefs.Deal> = new extensions.NumberFieldInfo<DealQuery, typedefs.Deal>(DealQuery._instance, "DealNo"); 
      public RoundId: extensions.NumberFieldInfo<DealQuery, typedefs.Deal> = new extensions.NumberFieldInfo<DealQuery, typedefs.Deal>(DealQuery._instance, "RoundId"); 
      public Round: extensions.SingleAssociationFieldInfo<DealQuery, typedefs.Deal, RoundQuery, typedefs.Round> = new extensions.SingleAssociationFieldInfo<DealQuery, typedefs.Deal, RoundQuery, typedefs.Round>(DealQuery._Instance, "Round");
   }

   export class RoundQuery
   {
      private static _instance: RoundQuery = null;
      static get _Instance(): RoundQuery {
          if (RoundQuery._instance == null)
              RoundQuery._instance = new RoundQuery();
          return RoundQuery._instance;
      }
      public Id: extensions.NumberFieldInfo<RoundQuery, typedefs.Round> = new extensions.NumberFieldInfo<RoundQuery, typedefs.Round>(RoundQuery._instance, "Id"); 
      public EventId: extensions.NumberFieldInfo<RoundQuery, typedefs.Round> = new extensions.NumberFieldInfo<RoundQuery, typedefs.Round>(RoundQuery._instance, "EventId"); 
      public RoundNo: extensions.NumberFieldInfo<RoundQuery, typedefs.Round> = new extensions.NumberFieldInfo<RoundQuery, typedefs.Round>(RoundQuery._instance, "RoundNo"); 
      public Deals: extensions.MultiAssociationFieldInfo<RoundQuery, typedefs.Round, DealQuery, typedefs.Deal> = new extensions.MultiAssociationFieldInfo<RoundQuery, typedefs.Round, DealQuery, typedefs.Deal>(RoundQuery._Instance, "Deals", DealQuery._Instance);
      public Event: extensions.SingleAssociationFieldInfo<RoundQuery, typedefs.Round, EventQuery, typedefs.Event> = new extensions.SingleAssociationFieldInfo<RoundQuery, typedefs.Round, EventQuery, typedefs.Event>(RoundQuery._Instance, "Event");
   }

   export class TableQuery
   {
      private static _instance: TableQuery = null;
      static get _Instance(): TableQuery {
          if (TableQuery._instance == null)
              TableQuery._instance = new TableQuery();
          return TableQuery._instance;
      }
      public Id: extensions.NumberFieldInfo<TableQuery, typedefs.Table> = new extensions.NumberFieldInfo<TableQuery, typedefs.Table>(TableQuery._instance, "Id"); 
      public TableNo: extensions.NumberFieldInfo<TableQuery, typedefs.Table> = new extensions.NumberFieldInfo<TableQuery, typedefs.Table>(TableQuery._instance, "TableNo"); 
      public Label: extensions.StringFieldInfo<TableQuery, typedefs.Table> = new extensions.StringFieldInfo<TableQuery, typedefs.Table>(TableQuery._instance, "Label"); 
      public EventId: extensions.NumberFieldInfo<TableQuery, typedefs.Table> = new extensions.NumberFieldInfo<TableQuery, typedefs.Table>(TableQuery._instance, "EventId"); 
      public Event: extensions.SingleAssociationFieldInfo<TableQuery, typedefs.Table, EventQuery, typedefs.Event> = new extensions.SingleAssociationFieldInfo<TableQuery, typedefs.Table, EventQuery, typedefs.Event>(TableQuery._Instance, "Event");
   }

   export class PairQuery
   {
      private static _instance: PairQuery = null;
      static get _Instance(): PairQuery {
          if (PairQuery._instance == null)
              PairQuery._instance = new PairQuery();
          return PairQuery._instance;
      }
      public Id: extensions.NumberFieldInfo<PairQuery, typedefs.Pair> = new extensions.NumberFieldInfo<PairQuery, typedefs.Pair>(PairQuery._instance, "Id"); 
      public Label: extensions.StringFieldInfo<PairQuery, typedefs.Pair> = new extensions.StringFieldInfo<PairQuery, typedefs.Pair>(PairQuery._instance, "Label"); 
      public PairNo: extensions.NumberFieldInfo<PairQuery, typedefs.Pair> = new extensions.NumberFieldInfo<PairQuery, typedefs.Pair>(PairQuery._instance, "PairNo"); 
      public EventId: extensions.NumberFieldInfo<PairQuery, typedefs.Pair> = new extensions.NumberFieldInfo<PairQuery, typedefs.Pair>(PairQuery._instance, "EventId"); 
      public FirstId: extensions.NumberFieldInfo<PairQuery, typedefs.Pair> = new extensions.NumberFieldInfo<PairQuery, typedefs.Pair>(PairQuery._instance, "FirstId"); 
      public SecondId: extensions.NumberFieldInfo<PairQuery, typedefs.Pair> = new extensions.NumberFieldInfo<PairQuery, typedefs.Pair>(PairQuery._instance, "SecondId"); 
      public Event: extensions.SingleAssociationFieldInfo<PairQuery, typedefs.Pair, EventQuery, typedefs.Event> = new extensions.SingleAssociationFieldInfo<PairQuery, typedefs.Pair, EventQuery, typedefs.Event>(PairQuery._Instance, "Event");
      public First: extensions.SingleAssociationFieldInfo<PairQuery, typedefs.Pair, PlayerQuery, typedefs.Player> = new extensions.SingleAssociationFieldInfo<PairQuery, typedefs.Pair, PlayerQuery, typedefs.Player>(PairQuery._Instance, "First");
      public Plan: extensions.MultiAssociationFieldInfo<PairQuery, typedefs.Pair, PairSeatingQuery, typedefs.PairSeating> = new extensions.MultiAssociationFieldInfo<PairQuery, typedefs.Pair, PairSeatingQuery, typedefs.PairSeating>(PairQuery._Instance, "Plan", PairSeatingQuery._Instance);
      public Second: extensions.SingleAssociationFieldInfo<PairQuery, typedefs.Pair, PlayerQuery, typedefs.Player> = new extensions.SingleAssociationFieldInfo<PairQuery, typedefs.Pair, PlayerQuery, typedefs.Player>(PairQuery._Instance, "Second");
   }

   export class PlayerQuery
   {
      private static _instance: PlayerQuery = null;
      static get _Instance(): PlayerQuery {
          if (PlayerQuery._instance == null)
              PlayerQuery._instance = new PlayerQuery();
          return PlayerQuery._instance;
      }
      public Id: extensions.NumberFieldInfo<PlayerQuery, typedefs.Player> = new extensions.NumberFieldInfo<PlayerQuery, typedefs.Player>(PlayerQuery._instance, "Id"); 
      public Name: extensions.StringFieldInfo<PlayerQuery, typedefs.Player> = new extensions.StringFieldInfo<PlayerQuery, typedefs.Player>(PlayerQuery._instance, "Name"); 
      public ShortName: extensions.StringFieldInfo<PlayerQuery, typedefs.Player> = new extensions.StringFieldInfo<PlayerQuery, typedefs.Player>(PlayerQuery._instance, "ShortName"); 
      public EventId: extensions.NumberFieldInfo<PlayerQuery, typedefs.Player> = new extensions.NumberFieldInfo<PlayerQuery, typedefs.Player>(PlayerQuery._instance, "EventId"); 
      public Event: extensions.SingleAssociationFieldInfo<PlayerQuery, typedefs.Player, EventQuery, typedefs.Event> = new extensions.SingleAssociationFieldInfo<PlayerQuery, typedefs.Player, EventQuery, typedefs.Event>(PlayerQuery._Instance, "Event");
      public Plan: extensions.MultiAssociationFieldInfo<PlayerQuery, typedefs.Player, PlayerSeatingQuery, typedefs.PlayerSeating> = new extensions.MultiAssociationFieldInfo<PlayerQuery, typedefs.Player, PlayerSeatingQuery, typedefs.PlayerSeating>(PlayerQuery._Instance, "Plan", PlayerSeatingQuery._Instance);
   }

   export class PlayerSeatingQuery
   {
      private static _instance: PlayerSeatingQuery = null;
      static get _Instance(): PlayerSeatingQuery {
          if (PlayerSeatingQuery._instance == null)
              PlayerSeatingQuery._instance = new PlayerSeatingQuery();
          return PlayerSeatingQuery._instance;
      }
      public Id: extensions.NumberFieldInfo<PlayerSeatingQuery, typedefs.PlayerSeating> = new extensions.NumberFieldInfo<PlayerSeatingQuery, typedefs.PlayerSeating>(PlayerSeatingQuery._instance, "Id"); 
      public RoundId: extensions.NumberFieldInfo<PlayerSeatingQuery, typedefs.PlayerSeating> = new extensions.NumberFieldInfo<PlayerSeatingQuery, typedefs.PlayerSeating>(PlayerSeatingQuery._instance, "RoundId"); 
      public TableId: extensions.NumberFieldInfo<PlayerSeatingQuery, typedefs.PlayerSeating> = new extensions.NumberFieldInfo<PlayerSeatingQuery, typedefs.PlayerSeating>(PlayerSeatingQuery._instance, "TableId"); 
      public PlayerId: extensions.NumberFieldInfo<PlayerSeatingQuery, typedefs.PlayerSeating> = new extensions.NumberFieldInfo<PlayerSeatingQuery, typedefs.PlayerSeating>(PlayerSeatingQuery._instance, "PlayerId"); 
      public Seat: extensions.StringFieldInfo<PlayerSeatingQuery, typedefs.PlayerSeating> = new extensions.StringFieldInfo<PlayerSeatingQuery, typedefs.PlayerSeating>(PlayerSeatingQuery._instance, "Seat"); 
      public Player: extensions.SingleAssociationFieldInfo<PlayerSeatingQuery, typedefs.PlayerSeating, PlayerQuery, typedefs.Player> = new extensions.SingleAssociationFieldInfo<PlayerSeatingQuery, typedefs.PlayerSeating, PlayerQuery, typedefs.Player>(PlayerSeatingQuery._Instance, "Player");
      public Round: extensions.SingleAssociationFieldInfo<PlayerSeatingQuery, typedefs.PlayerSeating, RoundQuery, typedefs.Round> = new extensions.SingleAssociationFieldInfo<PlayerSeatingQuery, typedefs.PlayerSeating, RoundQuery, typedefs.Round>(PlayerSeatingQuery._Instance, "Round");
      public Table: extensions.SingleAssociationFieldInfo<PlayerSeatingQuery, typedefs.PlayerSeating, TableQuery, typedefs.Table> = new extensions.SingleAssociationFieldInfo<PlayerSeatingQuery, typedefs.PlayerSeating, TableQuery, typedefs.Table>(PlayerSeatingQuery._Instance, "Table");
   }

   export class PairSeatingQuery
   {
      private static _instance: PairSeatingQuery = null;
      static get _Instance(): PairSeatingQuery {
          if (PairSeatingQuery._instance == null)
              PairSeatingQuery._instance = new PairSeatingQuery();
          return PairSeatingQuery._instance;
      }
      public Id: extensions.NumberFieldInfo<PairSeatingQuery, typedefs.PairSeating> = new extensions.NumberFieldInfo<PairSeatingQuery, typedefs.PairSeating>(PairSeatingQuery._instance, "Id"); 
      public RoundId: extensions.NumberFieldInfo<PairSeatingQuery, typedefs.PairSeating> = new extensions.NumberFieldInfo<PairSeatingQuery, typedefs.PairSeating>(PairSeatingQuery._instance, "RoundId"); 
      public TableId: extensions.NumberFieldInfo<PairSeatingQuery, typedefs.PairSeating> = new extensions.NumberFieldInfo<PairSeatingQuery, typedefs.PairSeating>(PairSeatingQuery._instance, "TableId"); 
      public PairId: extensions.NumberFieldInfo<PairSeatingQuery, typedefs.PairSeating> = new extensions.NumberFieldInfo<PairSeatingQuery, typedefs.PairSeating>(PairSeatingQuery._instance, "PairId"); 
      public IsNS: extensions.BooleanFieldInfo<PairSeatingQuery, typedefs.PairSeating> = new extensions.BooleanFieldInfo<PairSeatingQuery, typedefs.PairSeating>(PairSeatingQuery._instance, "IsNS"); 
      public Pair: extensions.SingleAssociationFieldInfo<PairSeatingQuery, typedefs.PairSeating, PairQuery, typedefs.Pair> = new extensions.SingleAssociationFieldInfo<PairSeatingQuery, typedefs.PairSeating, PairQuery, typedefs.Pair>(PairSeatingQuery._Instance, "Pair");
      public Round: extensions.SingleAssociationFieldInfo<PairSeatingQuery, typedefs.PairSeating, RoundQuery, typedefs.Round> = new extensions.SingleAssociationFieldInfo<PairSeatingQuery, typedefs.PairSeating, RoundQuery, typedefs.Round>(PairSeatingQuery._Instance, "Round");
      public Table: extensions.SingleAssociationFieldInfo<PairSeatingQuery, typedefs.PairSeating, TableQuery, typedefs.Table> = new extensions.SingleAssociationFieldInfo<PairSeatingQuery, typedefs.PairSeating, TableQuery, typedefs.Table>(PairSeatingQuery._Instance, "Table");
   }

test/typedefs.ts

@@ -1,1 +0,1 @@
-import breeze = require("breeze-client");

declare module superdup.server.typedefs
{
   export interface Board extends breeze.Entity {
      Id: number;
      Guid: string;
      Code: string;
      BoardSeriesId: number;
      CardDistribution: string;
      BoardSeries: BoardSeries;
      Scores: BoardScore[];
   }

   export interface BoardSeries extends breeze.Entity {
      Id: number;
      Guid: string;
      Code: string;
      Name: string;
      Description: string;
      Boards: Board[];
   }

   export interface BoardScore extends breeze.Entity {
      Id: number;
      BoardId: number;
      Score: number;
      Count: number;
      Board: Board;
   }

}
+import breeze = require("breeze-client");

   export interface Event extends breeze.Entity {
      Id: number;
      EventName: string;
      EventTime: Date;
      EventLocation: string;
      AccountId: number;
      BoardSets: BoardSet[];
      Pairs: Pair[];
      Players: Player[];
      Rounds: Round[];
      Tables: Table[];
   }

   export interface BoardSet extends breeze.Entity {
      Id: number;
      Name: string;
      EventId: number;
      BoardRefs: BoardRef[];
      Event: Event;
   }

   export interface BoardRef extends breeze.Entity {
      Id: number;
      BoardRefNo: number;
      BoardGuid: string;
      BoardSetId: number;
      BoardSet: BoardSet;
      Plan: BoardAllocation[];
   }

   export interface BoardAllocation extends breeze.Entity {
      Id: number;
      DealId: number;
      TableId: number;
      BoardRefId: number;
      NSScore: number;
      EWScore: number;
      BoardRef: BoardRef;
      Deal: Deal;
      Table: Table;
   }

   export interface Deal extends breeze.Entity {
      Id: number;
      DealNo: number;
      RoundId: number;
      Round: Round;
   }

   export interface Round extends breeze.Entity {
      Id: number;
      EventId: number;
      RoundNo: number;
      Deals: Deal[];
      Event: Event;
   }

   export interface Table extends breeze.Entity {
      Id: number;
      TableNo: number;
      Label: string;
      EventId: number;
      Event: Event;
   }

   export interface Pair extends breeze.Entity {
      Id: number;
      Label: string;
      PairNo: number;
      EventId: number;
      FirstId: number;
      SecondId: number;
      Event: Event;
      First: Player;
      Plan: PairSeating[];
      Second: Player;
   }

   export interface Player extends breeze.Entity {
      Id: number;
      Name: string;
      ShortName: string;
      EventId: number;
      Event: Event;
      Plan: PlayerSeating[];
   }

   export interface PlayerSeating extends breeze.Entity {
      Id: number;
      RoundId: number;
      TableId: number;
      PlayerId: number;
      Seat: string;
      Player: Player;
      Round: Round;
      Table: Table;
   }

   export interface PairSeating extends breeze.Entity {
      Id: number;
      RoundId: number;
      TableId: number;
      PairId: number;
      IsNS: boolean;
      Pair: Pair;
      Round: Round;
      Table: Table;
   }

tsconfig.json

@@ -6,3 +6,3 @@ {
         "moduleResolution": "node",
-        "noImplicitAny": false,
+        "noImplicitAny": true,
         "removeComments": false,
@@ -9,0 +9,0 @@ "sourceMap": true,

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

422575

increased by44.33%

Number of package files

51

increased by13.33%

Lines of code

1083

increased by8.08%

Worsened metrics

Dependency count

6

increased by20%

Dependency changes

• + Added@types/grunt@^0.4.21

• + Added@types/grunt@0.4.31(transitive)

• + Added@types/node@22.9.3(transitive)

• + Addedundici-types@6.19.8(transitive)

• Updatedbreezets@^0.1.17