Breeze.js entità digitate

Question

C'è un modo per creare entità tipizzate usando Breeze nello stesso modo in cui JaySvcUtil funziona con JayData? Questo include il supporto Typescript? C'è anche un supporto generale per Typescript all'interno del framework Breeze?

Answer 1

Abbiamo piani per fare di più con TypeScript, ma non ci siamo ancora impegnati in un intervallo di tempo specifico. (Il lavoro di Boris, menzionato nel post di John, è sicuramente un ottimo inizio).

AGGIORNAMENTO: A partire dalla v 0.84.4, Breeze fornisce il supporto completo per TypeScript.

Per quanto riguarda la generazione automatica di classi Javascript in fase di progettazione per ciascuna entità; abbiamo avuto diverse discussioni interne su questo, ma stiamo davvero aspettando di vedere per cosa la comunità vota. Quasi certamente ci arriveremo a questo punto, ma i tuoi voti sul
UserVoice possono sicuramente accelerare il processo.

Answer 2

Per quanto riguarda il dattiloscritto, è sicuramente sul nostro radar. Come minimo creeremo un file 'declare' di TypeScript che consentirà una migliore intelligenza quando si usa Breeze.

Puoi votare su oltre UserVoice.

Fino ad allora è possibile utilizzare Boris Yankov DefinitelyTyped che supporta Breeze.

Answer 3

miei due centesimi ...

ho utilizzato il file di definizione definatelytyped per brezza e sembra funzionare bene.

È abbastanza semplice creare uno script T4 per generare file .d.ts per tutte le entità in un .edmx e quindi ottenere l'intellisense che desideri. Se piace a Ward, potrei pubblicare un esempio di script T4 da qualche parte.

Answer 4

Questo elenco contiene una versione modificata di T4TS che contiene un supporto iniziale per la generazione di "classi Javascript per la progettazione per ogni entità" con supporto per Breeze.

https://gist.github.com/alexdresko/5393155

Finora, è adatta alle mie esigenze. Sono abbastanza sicuro che è necessario avere la definizione DefinitelyTyped Breeze nella tua soluzione affinché funzioni correttamente.

Forse questo è qualcosa che potrebbe essere aggiunto a T4TS in modo permanente? Forse è qualcosa che il team di Breeze dovrebbe prendere in considerazione? O forse è solo stupido e non funziona davvero per nessuno tranne me. :)

Nel mio Dataservice, posso fare qualcosa di simile:

createOrganization() : T4TS.Organization { 
     return <T4TS.Organization>this.manager.createEntity("Organization"); 
    } 

Poi, nel mio VM, tutto questo codice è ben typesafe ..

organizationSubmit() { 
     this.editingOrganization(false); 
     var newOrganization = this.dataservice.createOrganization(); 

     newOrganization.Name(this.organizationNameInput()); 
     if (newOrganization.entityAspect.validateEntity()) { 
      this.extendOrganization(newOrganization); 
      this.organizations.push(newOrganization); 
      this.dataservice.saveChanges(); 
      this.organizationNameInput(""); 
     } else { 
      this.handleItemErrors(newOrganization); 

     } 
    }; 

io in realtà non sapere dove andare con questo da qui. Ho provato a forare T4TS, ma non ho avuto il tempo di capire il suo sistema di build. Da qui l'essenza. Le opinioni sono certamente benvenute.

Answer 5

Di seguito è una pagina che è possibile rilasciare nel sito per generare definizioni di interfaccia dattiloscritto. La pagina recupera i metadati di brezza, quindi itera su tutti i tipi e genera una dichiarazione dell'interfaccia dattiloscritto per ciascun tipo.L'output di questa pagina può quindi essere incollato in qualsiasi file typescript (* .ts) o file di definizione dattiloscritto (* .d.ts). Includere i risultati in una dichiarazione di modulo se si desidera assegnare un nome all'interfaccia: declare module northwind { ... paste interfaces here... }.

Prima di utilizzare la pagina, è necessario effettuare una modifica: modificare l'url del controller del gestore entità da "api/northwind" a qualsiasi URL del proprio breeze controller.

Le interfacce generati hanno una dipendenza definizioni dattiloscritto Knockout.js cui è possibile afferrare qui: https://github.com/borisyankov/DefinitelyTyped/tree/master/knockout/

Utilizzando l'esempio Northwind dal learn.breezejs.com, l'uscita di questa pagina generatore di definizioni sarebbe qualcosa di simile a questo:

export interface Employee extends breeze.Entity { 
    FirstName: KnockoutObservable<string>; 
    LastName: KnockoutObservable<string>; 
} 

si potrebbe poi eseguire una query utilizzando brezza e il cast dei risultati di una serie di dipendenti in questo modo:

var manager = new breeze.EntityManager('api/northwind'); 

var query = new breeze.EntityQuery() 
    .from("Employees"); 

manager.executeQuery(query).then(data => { 
    // ***cast the results to a strongly typed array of Employee*** 
    var employees = <Employee[]>data.results; 
}).fail(e => { 
    alert(e); 
}); 

di seguito è la pagina del generatore di definizioni: aggiungere un nuovo file html al progetto denominato "definitions.html", eseguire il progetto e accedere alla pagina.

<html> 
<head> 
    <title>Typescript Definition Generator</title> 
    <style> 
     code { 
      white-space: pre; 
     } 
    </style> 
    <script src="//code.jquery.com/jquery-2.1.0.min.js"></script> 
    <script src="//ajax.aspnetcdn.com/ajax/knockout/knockout-3.0.0.js"></script> 
    <script src="//cdnjs.cloudflare.com/ajax/libs/q.js/1.0.0/q.min.js"></script> 
    <script src="//cdnjs.cloudflare.com/ajax/libs/breezejs/1.4.4/breeze.min.js"></script> 
    <script type="text/javascript"> 
     $(document).ready(function() { 
      var entityManager = new breeze.EntityManager('api/northwind'); 
      entityManager.fetchMetadata() 
       .then(function() { 
        var html = '', 
         types = entityManager.metadataStore.getEntityTypes(), 
         type, 
         i, 
         j, 
         property, 
         crlf = String.fromCharCode(13), 
         code = document.createElement('code'), 
         script = document.createElement('script'); 

        function getJSType(metadataType) { 
         if (/(Int64)|(Int32)|(Int16)|(Byte)|(Decimal)|(Double)|(Single)|(number)/.test(metadataType)) 
          return 'number'; 
         else if (/(DateTime)|(DateTimeOffset)|(Time)|(Date)/.test(metadataType)) 
          return 'Date'; 
         else if (/(Boolean)/i.test(metadataType)) 
          return 'boolean'; 
         return 'string'; 
        } 

        for (i = 0; i < types.length; i++) { 
         // type declaration 
         var type = types[i]; 
         html += 'export interface ' + type.shortName; 

         // base type 
         html += ' extends '; 
         if (type.hasOwnProperty('baseEntityType')) { 
          html += type.baseEntityType.shortName; 
         } else { 
          html += 'breeze.Entity'; 
         } 
         html += ' {' + crlf; 

         // data properties 
         for (j = 0; j < type.dataProperties.length; j++) { 
          property = type.dataProperties[j]; 
          if (type.baseEntityType && type.baseEntityType.dataProperties.filter(function (p) { return p.name === property.name; }).length > 0) 
           continue; 
          html += ' ' + property.name; 
          //if (property.isNullable) 
          // html += '?'; 
          html += ': KnockoutObservable&lt;'; 
          html += getJSType(property.dataType.name); 
          html += '&gt;; //' + property.dataType.name + crlf; 
         } 

         // navigation properties 
         for (j = 0; j < type.navigationProperties.length; j++) { 
          property = type.navigationProperties[j]; 
          if (type.baseEntityType && type.baseEntityType.navigationProperties.filter(function (p) { return p.name === property.name; }).length > 0) 
           continue; 
          html += ' ' + property.name; 
          //if (property.isNullable) 
          // html += '?'; 
          if (property.isScalar) 
           html += ': KnockoutObservable&lt;'; 
          else 
           html += ': KnockoutObservableArray&lt;'; 
          html += property.entityType.shortName; 
          html += '&gt;;' + crlf; 
         } 

         html += '}' + crlf + crlf; 
        } 

        code.innerHTML = html; 

        $(code).addClass('prettyprint'); 

        document.body.appendChild(code); 

        script.setAttribute('src', '//google-code-prettify.googlecode.com/svn/loader/run_prettify.js'); 
        document.body.appendChild(script); 
       }) 
       .fail(function (reason) { 
        alert(reason); 
       }); 
     }); 
    </script> 
</head> 
<body> 
</body> 
</html> 

Answer 6

Per defiintions brezza tipografico, usare il pacchetto NuGet breeze.TypeScript.DefinitelyTyped. Per creare definizioni per le tue entità, puoi utilizzare TypeLITE. Si creerà un file .d.ts con interfacce in questo modo:

declare module MyProject.Models { 
interface Customer { 
    Id: number; 
    AccountNumber: string; 
    ... 

Mentre queste interfacce descrivono pienamente le vostre entità, che non si estendono breeze.Entity. Per giocare bene con le definizioni del tipo Breeze API, derivare le proprie interfacce a questi, in questo modo:

import Models = MyProject.Models; 
interface Customer extends Models.Customer, breeze.Entity { } 
... 

Questo comporta ancora un po 'di codifica manuale, ma almeno è solo per tipo, non per immobile.