@terreno/api 0.0.17 → 0.1.0

package/src/permissions.ts

@@ -1,5 +1,5 @@
 // Defaults closed
-import * as Sentry from "@sentry/node";
+import * as Sentry from "@sentry/bun";
 import type express from "express";
 import type {NextFunction} from "express";
 import mongoose, {type Model} from "mongoose";

package/src/plugins.test.ts

@@ -39,9 +39,9 @@ interface StuffModelType extends Model<Stuff> {
 }
 
 const stuffSchema = new Schema<Stuff>({
-  date: DateOnly,
-  name: String,
-  ownerId: String,
+  date: {description: "The date associated with this item", type: DateOnly as any},
+  name: {description: "The name of the item", type: String},
+  ownerId: {description: "The user who owns this item", type: String},
 });
 
 stuffSchema.plugin(isDeletedPlugin);

package/src/terrenoPlugin.ts

@@ -0,0 +1,5 @@
+import type express from "express";
+
+export interface TerrenoPlugin {
+  register(app: express.Application): void;
+}

package/src/tests/bunSetup.ts

@@ -93,8 +93,8 @@ afterEach(() => {
   logs = [];
 });
 
-// Mock @sentry/node module
-mock.module("@sentry/node", () => {
+// Mock @sentry/bun module
+mock.module("@sentry/bun", () => {
   const mockFn = (): ReturnType<typeof mock> => mock(() => {});
 
   // Mock Scope

package/src/tests.ts

@@ -54,10 +54,10 @@ export interface Food {
 }
 
 const userSchema = new Schema<User>({
-  admin: {default: false, type: Boolean},
-  age: Number,
-  name: String,
-  username: String,
+  admin: {default: false, description: "Whether the user has admin privileges", type: Boolean},
+  age: {description: "The user's age", type: Number},
+  name: {description: "The user's display name", type: String},
+  username: {description: "The user's username", type: String},
 });
 
 userSchema.plugin(passportLocalMongoose as any, {
@@ -80,55 +80,65 @@ userSchema.methods.postCreate = async function (body: any) {
 export const UserModel = model<User>("User", userSchema);
 
 const superUserSchema = new Schema<SuperUser>({
-  superTitle: {required: true, type: String},
+  superTitle: {description: "The super user's title", required: true, type: String},
 });
 export const SuperUserModel = UserModel.discriminator("SuperUser", superUserSchema);
 
 const staffUserSchema = new Schema<StaffUser>({
-  department: {required: true, type: String},
+  department: {
+    description: "The department the staff member belongs to",
+    required: true,
+    type: String,
+  },
 });
 export const StaffUserModel = UserModel.discriminator("Staff", staffUserSchema);
 
 const foodCategorySchema = new Schema<FoodCategory>(
   {
-    name: String,
-    show: Boolean,
+    name: {description: "The name of the food category", type: String},
+    show: {description: "Whether this category is visible", type: Boolean},
   },
   {timestamps: {createdAt: "created", updatedAt: "updated"}}
 );
 
 const likesSchema = new Schema<any>({
-  likes: Boolean,
-  userId: {ref: "User", type: "ObjectId"},
+  likes: {description: "Whether the user liked the item", type: Boolean},
+  userId: {description: "The user who liked the item", ref: "User", type: "ObjectId"},
 });
 
 const foodSchema = new Schema<Food>(
   {
-    calories: Number,
-    categories: [foodCategorySchema],
-    created: Date,
+    calories: {description: "Number of calories in the food", type: Number},
+    categories: {description: "Categories this food belongs to", type: [foodCategorySchema]},
+    created: {description: "When this food was created", type: Date},
     eatenBy: [
       {
+        description: "Users who have eaten this food",
         ref: "User",
         required: true,
         type: Schema.Types.ObjectId,
       },
     ],
-    expiration: DateOnly,
-    hidden: {default: false, type: Boolean},
+    expiration: {description: "Expiration date of the food", type: DateOnly as any},
+    hidden: {
+      default: false,
+      description: "Whether this food is hidden from listings",
+      type: Boolean,
+    },
     lastEatenWith: {
+      description: "Map of user names to dates they last ate this food with",
       of: Date,
       type: Map,
     },
-    likesIds: {required: true, type: [likesSchema]},
-    name: String,
-    ownerId: {ref: "User", type: "ObjectId"},
+    likesIds: {description: "User likes for this food", required: true, type: [likesSchema]},
+    name: {description: "The name of the food", type: String},
+    ownerId: {description: "The user who owns this food entry", ref: "User", type: "ObjectId"},
     source: {
-      dateAdded: String,
-      href: String,
-      name: String,
+      dateAdded: {description: "When the source was added", type: String},
+      href: {description: "URL of the source", type: String},
+      name: {description: "Name of the source", type: String},
     },
-    tags: [String],
+    tags: {description: "Tags associated with this food", type: [String]},
   },
   {strict: "throw", toJSON: {virtuals: true}, toObject: {virtuals: true}}
 );
@@ -145,8 +155,8 @@ interface RequiredField {
 }
 
 const requiredSchema = new Schema<RequiredField>({
-  about: String,
-  name: {required: true, type: String},
+  about: {description: "Information about the item", type: String},
+  name: {description: "The name of the item", required: true, type: String},
 });
 export const RequiredModel = model<RequiredField>("Required", requiredSchema);
 

package/CLAUDE.md

@@ -1,107 +0,0 @@
-# @terreno/api
-
-REST API framework built on Express/Mongoose, styled after Django REST Framework.
-
-## Commands
-
-```bash
-bun run compile          # Compile TypeScript
-bun run dev              # Watch mode
-bun run test             # Run tests
-bun run lint             # Lint code
-bun run lint:fix         # Fix lint issues
-```
-
-## Architecture
-
-### modelRouter
-
-Automatically creates RESTful CRUD APIs for Mongoose models with built-in permissions, population, filtering, and lifecycle hooks.
-
-```typescript
-import {modelRouter, modelRouterOptions, Permissions} from "@terreno/api";
-
-const router = modelRouter(YourModel, {
-  permissions: {
-    list: [Permissions.IsAuthenticated],
-    create: [Permissions.IsAuthenticated],
-    read: [Permissions.IsOwner],
-    update: [Permissions.IsOwner],
-    delete: [],  // Disabled
-  },
-  sort: "-created",
-  queryFields: ["_id", "type", "name"],
-});
-```
-
-### Custom Routes
-
-For non-CRUD endpoints, use the OpenAPI builder:
-
-```typescript
-import {asyncHandler, authenticateMiddleware, createOpenApiBuilder} from "@terreno/api";
-
-router.get("/yourRoute/:id", [
-  authenticateMiddleware(),
-  createOpenApiBuilder(options)
-    .withTags(["yourTag"])
-    .withSummary("Brief summary")
-    .withPathParameter("id", {type: "string"})
-    .withResponse(200, {data: {type: "object"}})
-    .build(),
-], asyncHandler(async (req, res) => {
-  return res.json({data: result});
-}));
-```
-
-## Conventions
-
-### Error Handling
-- Throw `APIError` with appropriate status codes: `throw new APIError({status: 400, title: "Message"})`
-- Services should throw user-friendly errors
-
-### Mongoose
-- Do not use `Model.findOne` - use `Model.findExactlyOne` or `Model.findOneOrThrow`
-- Define statics/methods by direct assignment: `schema.methods = {bar() {}}`
-- All model types live in `src/modelInterfaces.ts`
-
-### User Type Casting
-- In API routes: `req.user` is `UserDocument | undefined`
-- In @terreno/api callbacks: cast with `const user = u as unknown as UserDocument`
-- Never use `as any as UserDocument`
-
-### Logging
-- Use `logger.info/warn/error/debug` for permanent logs (not `console.log`)
-
-### Testing
-- Use bun test with expect for testing
-- Use existing manual mocks from `src/__mocks__/`
-- Never mock @terreno/api or models
-
-## Model Type Generation
-
-When creating/modifying Mongoose models, update `src/modelInterfaces.ts`:
-
-```typescript
-export type YourModelMethods = {
-  customMethod: (this: YourModelDocument, param: string) => Promise<void>;
-};
-
-export type YourModelStatics = DefaultStatics<YourModelDocument> & {
-  customStatic: (this: YourModelModel, param: string) => Promise<YourModelDocument>;
-};
-
-export type YourModelModel = DefaultModel<YourModelDocument> & YourModelStatics;
-export type YourModelSchema = mongoose.Schema<YourModelDocument, YourModelModel, YourModelMethods>;
-export type YourModelDocument = DefaultDoc & YourModelMethods & {
-  fieldName: string;
-};
-```
-
-## SDK Generation
-
-After modifying routes, regenerate the SDK:
-
-```bash
-bun run sdk
-```

package/dist/response.js

@@ -1 +0,0 @@
-"use strict";

package/index.ts

@@ -1 +0,0 @@
-console.log("Hello via Bun!");