create-cloesce 0.3.2 → 0.3.4

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "create-cloesce",
   "description": "Create Cloesce App",
-  "version": "0.3.2",
+  "version": "0.3.4",
   "author": "Ben Schreiber <bpschreiber2003@gmail.com>",
   "repository": {
     "url": "https://github.com/bens-schreiber/create-cloesce-app"

package/templates/default/gitignore

@@ -1,5 +1,5 @@
 # Cloesce
-.generated
+.cloesce
 dist
 
 ### Node ###

package/templates/default/src/api/main.ts

@@ -1,36 +1,45 @@
 // Here, we import the generated backend code, which includes all the types
 // defined in the `schema.clo` file
-import * as Cloesce from "@cloesce/backend.js";
+import * as clo from "@cloesce/backend.js";
 import { CfReadableStream } from "@cloesce/backend.js";
 
 // The "cloesce" library provides basic types and utilities for building a Cloesce backend
 import { HttpResult } from "cloesce";
 
-// All API routes defined under a model in `schema.clo` are generated under their
-// respective models namespace.
+
+// To implement the API routes of a model or service defined in `schema.clo`,
+// we can use the `impl` method on it's respective generated namespace.
+//
+// In addition to defining the routes, `Weather` will inherit all of the static utility methods
+// from the generated `Orm`, `Key` and `Source`.
 //
-// To implement an API route, simply extend the generated Api class.
-// If not implemented, the route will return a 501 Not Implemented error by default.
-export class Weather extends Cloesce.Weather.Api {
-    async uploadPhoto(self: Cloesce.Weather.Self, e: Cloesce.Env, s: CfReadableStream): Promise<void> {
-        // All models have a `KeyFormat` namespace which provides utilities for generating
+// The only place where generated code should be directly used is in `impl` blocks like this.
+export const Weather = clo.Weather.impl({
+    async uploadPhoto(self, e, s: CfReadableStream) {
+        // All models have a `Key` namespace which provides utilities for generating
         // KV and R2 keys for that model.
-        const key = Cloesce.Weather.KeyFormat.photo(self.id);
+        const key = this.Key.photo(self.id);
         await e.bucket.put(key, s);
-    }
+    },
 
-    // Any method can return an HttpResult, which allows you to specify the 
-    // Response status code, body, and headers.
-    downloadPhoto(self: Cloesce.Weather.Self): HttpResult<CfReadableStream> {
+    downloadPhoto(self) {
+        // Any method can return an HttpResult, which allows you to specify the 
+        // Response status code, body, and headers.
         if (!self.photo) {
             return HttpResult.fail(404, "Photo not found");
         }
         return HttpResult.ok(200, self.photo.body);
     }
-}
+});
+
+// `WeatherReport` has no API routes defined.
+//
+// Instead of using the generated namespace directly, we can still create an implementation with `impl`
+// to avoid passing the generated code around the rest of our application.
+export const WeatherReport = clo.WeatherReport.impl({});
 
 export default {
-    async fetch(request: Request, env: Cloesce.Env): Promise<Response> {
+    async fetch(request: Request, env: clo.Env): Promise<Response> {
         // preflight
         if (request.method === "OPTIONS") {
             return HttpResult.ok(200, undefined, {
@@ -41,8 +50,8 @@ export default {
         }
 
         // Run Cloesce app
-        const app = (await Cloesce.cloesce())
-            .register(new Weather());
+        const app = (await clo.cloesce())
+            .register(Weather);
 
         const result = await app.run(request, env);
 

package/templates/default/src/schema/schema.clo

@@ -2,14 +2,14 @@
 // It does not replace the wrangler config, but does result in a generated version.
 env {
     // The `d1` block describes all D1 database bindings
-    d1 { 
-        db 
+    d1 {
+        db
         // db2
     }
-
+    
     // The `r2` block describes all R2 bucket bindings
-    r2 { 
-        bucket 
+    r2 {
+        bucket
         // bucket2
     }
 }
@@ -26,7 +26,7 @@ model WeatherReport {
     primary {
         id: int
     }
-
+    
     // A `nav` block describes a relationship between two models.
     // In this case, it is a one-to-many relationship between WeatherReport and Weather,
     // where WeatherReport has many Weathers. 
@@ -35,11 +35,11 @@ model WeatherReport {
     // references the `id` field in the WeatherReport model.
     //
     // This will resolve to a navigation field named `weatherEntries` in the WeatherReport model, 
-    //which is an array of Weather objects.
+    // which is an array of Weather objects.
     nav (Weather::weatherReportId) {
         weatherEntries
     }
-
+    
     // All fields that are not apart of a block are just regular fields in the table.
     title: string
     description: string
@@ -51,21 +51,24 @@ model Weather {
     primary {
         id: int
     }
-
+    
     // A `foreign` block describes a one to one relationship between two models.
     // It translates directly to a foreign key constraint in the database (`weatherReportId` references `id` in WeatherReport).
     foreign (WeatherReport::id) {
         weatherReportId
-
+        
+        
         // A `nav` block inside a `foreign` block generates a navigation field,
         // meaning the backend and client will have a WeatherReport object named `weatherReport` nested inside the Weather model.
-        nav { weatherReport }
+        nav {
+            weatherReport
+        }
     }
     
     r2 (bucket, "weather/photos/{id}.jpg") {
         photo
     }
-
+    
     dateTime: date
     location: string
     temperature: int
@@ -83,7 +86,7 @@ api Weather {
     // In this case, `uploadPhoto` accepts the Wrangler environment (dependency injected),
     // and a stream (the photo to be uploaded).
     post uploadPhoto(self, e: env, s: stream) -> void
-
+    
     // By default, Cloesce will hydrate a `self` instance with all 1:1, KV, R2,
     // and the near side of 1:M/M:M relationships.
     //
@@ -98,5 +101,7 @@ api Weather {
 //
 // In this case, the include tree has only the `photo` field of `Weather`.
 source R2Only for Weather {
-    include { photo }
+    include {
+        photo
+    }
 }

package/templates/default/test/weather.test.ts

@@ -1,7 +1,6 @@
 import { Miniflare } from "miniflare";
 import { describe, test, expect, beforeAll } from "vitest";
-import * as Cloesce from "@cloesce/backend.js";
-import { Weather } from "@api/main.js"
+import { Weather, WeatherReport } from "@api/main.js"
 import { cloesce } from "@cloesce/backend.js";
 
 async function createTestEnv() {
@@ -56,7 +55,7 @@ describe("Miniflare Integration Tests", () => {
         const env = await createTestEnv();
         const testData = "test-data";
 
-        const report = (await Cloesce.WeatherReport.save(env, {
+        const report = (await WeatherReport.Orm.save(env, {
             title: "Test Report",
             description: "This is a test weather report.",
             weatherEntries: [{
@@ -67,11 +66,11 @@ describe("Miniflare Integration Tests", () => {
             }]
         }))!;
 
-        await new Weather().uploadPhoto(report.weatherEntries[0], env, testData as any);
+        await Weather.uploadPhoto(report.weatherEntries[0], env, testData as any);
 
         // Act
-        const weatherEntries = (await Cloesce.Weather.DataSources.Default.list(env, 0, 100))!;
-        const photo = new Weather().downloadPhoto(weatherEntries[0]);
+        const weatherEntries = (await Weather.Default.list(env, 0, 100))!;
+        const photo = Weather.downloadPhoto(weatherEntries[0]);
 
         // Assert
         expect(photo.ok).toBe(true);