create-cloesce 0.3.3 → 0.3.4

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "create-cloesce",
   "description": "Create Cloesce App",
-  "version": "0.3.3",
+  "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/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);