create-cloesce 0.3.3 → 0.4.0

package/package.json

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

@@ -10,7 +10,7 @@
     "test": "vitest"
   },
   "dependencies": {
-    "cloesce": ">=0.3.0",
+    "cloesce": ">=0.4.0",
     "wrangler": "^4.61.1"
   },
   "devDependencies": {

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

@@ -16,9 +16,8 @@ env {
 
 // If a model is to be stored in a D1 database as a table, it must be decorated with `[use <binding>]`
 // The `list`, `get`, and `save` operations are used to generate CRUD operations for the model.
-// Optionally, these tags can be combined, e.g. `[use db, list, get, save]`
 [use db]
-[use list, save, get]
+[crud list, save, get]
 model WeatherReport {
     // The `primary` block describes the primary key of the table.
     // It can be composed of several fields. Any number of primary blocks can be defined,
@@ -26,6 +25,12 @@ model WeatherReport {
     primary {
         id: int
     }
+
+    // Define regular SQL columns under the `column` block.
+    column {
+        title: string
+        description: string
+    }
     
     // A `nav` block describes a relationship between two models.
     // In this case, it is a one-to-many relationship between WeatherReport and Weather,
@@ -39,25 +44,27 @@ model WeatherReport {
     nav (Weather::weatherReportId) {
         weatherEntries
     }
-    
-    // All fields that are not apart of a block are just regular fields in the table.
-    title: string
-    description: string
 }
 
 [use db]
-[use get, list, save]
+[crud get, list, save]
 model Weather {
     primary {
         id: int
     }
+
+    column {
+        dateTime: date
+        location: string
+        temperature: int
+        condition: string
+    }
     
     // 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 {
@@ -68,11 +75,6 @@ model Weather {
     r2 (bucket, "weather/photos/{id}.jpg") {
         photo
     }
-    
-    dateTime: date
-    location: string
-    temperature: int
-    condition: string
 }
 
 // An `api` block describes what endpoints must be implemented in the backend
@@ -85,7 +87,8 @@ 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
+    [inject bucket]
+    post uploadPhoto(self, s: stream)
     
     // By default, Cloesce will hydrate a `self` instance with all 1:1, KV, R2,
     // and the near side of 1:M/M:M relationships.

package/templates/default/src/web/index.ts

@@ -23,10 +23,7 @@ const showResult = (outputId: string, result: any) => {
 };
 
 window.listReports = async () => {
-    const result = await WeatherReport.$list({
-        lastSeen_id: 0,
-        limit: 100
-    })
+    const result = await WeatherReport.$list(0, 100);
     showResult('list-output', result);
 };
 
@@ -51,9 +48,7 @@ window.addWeatherEntry = async () => {
         return;
     }
 
-    const getResult = await WeatherReport.$get({
-        id: reportId
-    });
+    const getResult = await WeatherReport.$get(reportId);
     if (!getResult.ok) {
         showResult('entry-output', getResult);
         return;

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: [{
@@ -65,13 +64,13 @@ describe("Miniflare Integration Tests", () => {
                 temperature: 25,
                 condition: "Sunny"
             }]
-        }))!;
+        })).value!;
 
-        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)).value!;
+        const photo = Weather.downloadPhoto(weatherEntries[0]);
 
         // Assert
         expect(photo.ok).toBe(true);