@rebasepro/cli 0.10.0 → 0.10.1-canary.0a881d4

package/dist/manifest.d.ts

@@ -0,0 +1,83 @@
+import type { ManagedCompatibility, RebaseAppConfig, RebaseBackendAppConfig, RebaseProjectManifest } from "@rebasepro/types";
+/** Runtime range written into new manifests. */
+export declare const CURRENT_RUNTIME_RANGE = "^1";
+/** Conventional locations, matching what `rebase init` scaffolds. */
+export declare const DEFAULT_CONFIG_DIR = "config";
+export declare const DEFAULT_FUNCTIONS_DIR = "backend/functions";
+export declare const DEFAULT_CRONS_DIR = "backend/crons";
+export declare const DEFAULT_SCHEMA_FILE = "backend/src/schema.generated.ts";
+export interface ManifestValidationIssue {
+    /** Dotted path to the offending value, e.g. `apps.web.output`. */
+    path: string;
+    message: string;
+}
+export interface LoadedManifest {
+    manifest: RebaseProjectManifest;
+    /** Where it came from — a real file, or inferred from the directory layout. */
+    source: "file" | "synthesized";
+    /** Absolute path to `rebase.json`, when one exists. */
+    filePath?: string;
+}
+export declare class ManifestError extends Error {
+    readonly issues: ManifestValidationIssue[];
+    constructor(message: string, issues?: ManifestValidationIssue[]);
+}
+/**
+ * Validate a parsed manifest, collecting every problem.
+ */
+export declare function validateManifest(raw: unknown): {
+    manifest?: RebaseProjectManifest;
+    issues: ManifestValidationIssue[];
+};
+/**
+ * Infer a manifest from a directory that does not have one.
+ *
+ * This mirrors exactly what the template scaffolds, which is what makes adopting
+ * the manifest a no-op for existing projects: the synthesized result is what
+ * they would have written by hand.
+ *
+ * An ejected backend — one with its own `src/index.ts` entrypoint — is reported
+ * as a `custom` app rather than a `backend` app. That is not a downgrade; it is
+ * an accurate description, and it is what keeps such a project deploying exactly
+ * as it does today.
+ */
+export declare function synthesizeManifest(projectRoot: string): RebaseProjectManifest;
+export declare function manifestPath(projectRoot: string): string;
+export declare function manifestExists(projectRoot: string): boolean;
+/**
+ * Read the manifest, falling back to a synthesized one.
+ *
+ * A malformed manifest throws — unlike a missing one. Silently ignoring a file
+ * the developer wrote, and building something else instead, is the worst
+ * available behaviour.
+ */
+export declare function loadManifest(projectRoot: string): LoadedManifest;
+/** Write a manifest, with a trailing newline so it plays well with other tools. */
+export declare function writeManifest(projectRoot: string, manifest: RebaseProjectManifest): string;
+/** Find the single backend app, if this repository declares one. */
+export declare function findBackendApp(manifest: RebaseProjectManifest): {
+    name: string;
+    app: RebaseBackendAppConfig;
+} | undefined;
+/** Apps that produce build output, in the order they should be built. */
+export declare function buildableApps(manifest: RebaseProjectManifest): {
+    name: string;
+    app: RebaseAppConfig;
+}[];
+/**
+ * Decide whether a project can run on the managed runtime, and say why not.
+ *
+ * "Not eligible" is never a dead end — it selects the custom-runtime path, which
+ * still deploys. The reasons exist so the answer is actionable rather than a
+ * verdict.
+ */
+export declare function assessManagedCompatibility(manifest: RebaseProjectManifest): ManagedCompatibility;
+/** Resolve a backend app's directories against the conventions it omits. */
+export declare function resolveBackendPaths(app: RebaseBackendAppConfig): {
+    config: string;
+    functions: string;
+    crons: string;
+    schema: string;
+    usersCollection: string;
+    mode: "cms" | "baas";
+};

package/dist/utils/package-manager.d.ts

@@ -19,14 +19,38 @@ export interface PMCommands {
     /** The workspace dependency protocol: `"workspace:*"` for pnpm, `"*"` for npm. */
     workspaceProtocol: string;
 }
+/**
+ * Decide availability from a `spawnSync` outcome.
+ *
+ * Split out from the spawn itself so the decision is testable without starting
+ * a process — which is what made the old test load-sensitive and occasionally
+ * red for reasons that had nothing to do with the code under test.
+ *
+ * The three outcomes are distinguishable, and the old code conflated two of
+ * them by asking only `status === 0`:
+ *
+ *   not installed   status null, signal null,    error.code ENOENT
+ *   timed out       status null, signal SIGTERM, error.code ETIMEDOUT
+ *   broken install  status non-zero, no error
+ */
+export declare function pnpmAvailabilityFromProbe(res: {
+    status: number | null;
+    signal?: NodeJS.Signals | null;
+    error?: {
+        code?: string;
+    } | Error;
+}): boolean;
 /**
  * Whether pnpm is runnable on this machine.
  *
  * Used to decide whether a fresh project can be scaffolded with pnpm. Kept
- * cheap and non-interactive (short timeout, output discarded) so it never
- * hangs detection if a corepack shim misbehaves.
+ * cheap and non-interactive (bounded timeout, output discarded) so it never
+ * hangs detection if a corepack shim misbehaves, and memoised so that repeated
+ * detection in one CLI run costs one process rather than one per call.
  */
 export declare function isPnpmAvailable(): boolean;
+/** Forget the memoised probe. For tests; nothing in a CLI run needs it. */
+export declare function resetPnpmAvailabilityCache(): void;
 /**
  * Detect the package manager for a Rebase project.
  *

package/dist/utils/project.d.ts

@@ -1,9 +1,17 @@
+/** The authored project manifest. Its presence alone marks a project root. */
+export declare const MANIFEST_FILENAME = "rebase.json";
 /**
  * Walk up from `startDir` to find the Rebase project root.
  *
- * The root is identified by a `package.json` that either:
- * - has `workspaces` containing "backend" or "frontend", OR
- * - has a sibling `backend/` directory
+ * A directory is the root when it holds a `rebase.json`, or when it holds a
+ * `package.json` that either lists `backend` as a workspace or sits beside both
+ * `backend/` and `config/`.
+ *
+ * `rebase.json` is checked first and needs no `package.json` beside it, because
+ * the conventions below all describe a repository that *contains the backend*.
+ * A repository holding only a frontend — the normal shape once a project's apps
+ * live in separate repositories — matches none of them, so without this the
+ * tooling could not run there at all.
  */
 export declare function findProjectRoot(startDir?: string): string | null;
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rebasepro/cli",
-  "version": "0.10.0",
+  "version": "0.10.1-canary.0a881d4",
   "description": "Developer tools for Rebase projects",
   "main": "./dist/index.es.js",
   "module": "./dist/index.es.js",
@@ -31,12 +31,12 @@
     "execa": "^9.6.1",
     "inquirer": "14.0.2",
     "jiti": "^2.7.0",
-    "@rebasepro/agent-skills": "0.10.0",
-    "@rebasepro/codegen": "0.10.0",
-    "@rebasepro/client": "0.10.0",
-    "@rebasepro/server-postgres": "0.10.0",
-    "@rebasepro/types": "0.10.0",
-    "@rebasepro/server": "0.10.0"
+    "@rebasepro/client": "0.10.1-canary.0a881d4",
+    "@rebasepro/agent-skills": "0.10.1-canary.0a881d4",
+    "@rebasepro/codegen": "0.10.1-canary.0a881d4",
+    "@rebasepro/server-postgres": "0.10.1-canary.0a881d4",
+    "@rebasepro/server": "0.10.1-canary.0a881d4",
+    "@rebasepro/types": "0.10.1-canary.0a881d4"
   },
   "devDependencies": {
     "@types/node": "^25.9.3",
@@ -48,6 +48,7 @@
   },
   "files": [
     "bin/",
+    "runtime/",
     "dist/",
     "templates/"
   ],

package/runtime/dev-server.mjs

@@ -0,0 +1,43 @@
+/**
+ * The development entrypoint.
+ *
+ * Run under `tsx` by `rebase dev` for projects that have no hand-written
+ * `backend/src/index.ts`. It boots the same runtime a deployment does, over the
+ * project's TypeScript **source** rather than a compiled bundle — so hot reload
+ * still works, and development still predicts production because both go through
+ * one boot path.
+ *
+ * Paths arrive in the environment rather than as arguments because `tsx watch`
+ * owns the argument list.
+ */
+import path from "node:path";
+import fs from "node:fs";
+import dotenv from "dotenv";
+
+const projectRoot = process.env.REBASE_DEV_PROJECT_ROOT || process.cwd();
+
+const envFile = process.env.DOTENV_CONFIG_PATH;
+if (envFile && fs.existsSync(envFile)) {
+    dotenv.config({ path: envFile });
+}
+
+const { createSourceBundle, runFromBundle } = await import("@rebasepro/server");
+
+const optional = (value) => (value && value.length > 0 ? value : undefined);
+
+const bundle = createSourceBundle({
+    projectRoot,
+    config: optional(process.env.REBASE_DEV_CONFIG),
+    functions: optional(process.env.REBASE_DEV_FUNCTIONS),
+    crons: optional(process.env.REBASE_DEV_CRONS),
+    schema: optional(process.env.REBASE_DEV_SCHEMA),
+    mode: process.env.REBASE_DEV_MODE === "baas" ? "baas" : "cms",
+    app: optional(process.env.REBASE_DEV_APP)
+});
+
+// The dev port file and the graceful-shutdown handlers both key off the project
+// root, so make sure the process agrees with the CLI about where that is.
+process.chdir(projectRoot);
+void path;
+
+await runFromBundle({ bundle });

package/templates/overlays/baas/backend/src/index.ts

@@ -15,6 +15,7 @@ import {
 } from "@rebasepro/server";
 import { createPostgresDatabaseConnection, createPostgresAdapter } from "@rebasepro/server-postgres";
 import { env } from "./env.js";
+import { storageAuthorize } from "./storage.js";
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -122,6 +123,12 @@ pass: env.SMTP_PASS! }
                 }
                 : undefined
         },
+        // File storage is opt-in. With no bucket configured, storage is OFF in
+        // production — the upload routes answer 501 STORAGE_NOT_CONFIGURED —
+        // rather than writing to the container filesystem, which is erased on
+        // every restart and redeploy. Uploads that fail loudly are recoverable;
+        // uploads that succeed into a disk about to be wiped are not.
+        // Local disk stays the default in development, where it is what you want.
         storage: env.STORAGE_TYPE === "s3"
             ? {
                 type: "s3",
@@ -132,10 +139,27 @@ pass: env.SMTP_PASS! }
                 endpoint: env.S3_ENDPOINT,
                 forcePathStyle: env.S3_FORCE_PATH_STYLE
             }
-            : {
-                type: "local",
-                basePath: env.STORAGE_PATH || path.resolve(__dirname, "../../uploads")
-            },
+            : env.STORAGE_TYPE === "gcs"
+                ? {
+                    type: "gcs",
+                    bucket: env.GCS_BUCKET!,
+                    projectId: env.GCS_PROJECT_ID,
+                    keyFilename: env.GCS_KEY_FILENAME
+                }
+                // Set FORCE_LOCAL_STORAGE=true only if this deployment really
+                // does have a durable volume mounted at STORAGE_PATH.
+                : isProduction && !env.FORCE_LOCAL_STORAGE
+                    ? undefined
+                    : {
+                        type: "local",
+                        basePath: env.STORAGE_PATH || path.resolve(__dirname, "../../uploads")
+                    },
+        // Storage is not under row-level security, so this hook IS its access
+        // model — the server refuses to boot in production without one, because
+        // "signed in" would otherwise be the only thing between a caller and every
+        // file in the bucket. See storage.ts; the default scopes each caller to
+        // `users/<uid>/` and is meant to be replaced with your own rule.
+        storageAuthorize,
         history: true,
         enableSwagger: true
     });

package/templates/overlays/baas/backend/src/storage.ts

@@ -0,0 +1,71 @@
+import { isPublicStoragePath, type StorageAuthorize } from "@rebasepro/types";
+
+/**
+ * Who may do what to files in storage.
+ *
+ * Storage is **not** under row-level security. Tables are: a request runs as
+ * `rebase_user` and Postgres decides row by row. Object storage has no equivalent,
+ * so keys share one flat namespace and this hook is the whole authorization model.
+ * Without it the server refuses to boot in production, because "authenticated"
+ * would be the only thing between a signed-in caller and every file in the bucket —
+ * they can `GET /storage/list?prefix=` to enumerate every key, then read, overwrite
+ * or delete any of them.
+ *
+ * It lives in `backend/src/` rather than a config package because BaaS mode has no
+ * config package: collections come from the live database, so there is nothing to
+ * declare and nowhere else to put this.
+ *
+ * ## The default this starter ships
+ *
+ * A deliberately conservative one, because a BaaS project's storage semantics are
+ * whatever *your* application says they are and this file cannot know:
+ *
+ * | operation | who |
+ * | --- | --- |
+ * | `read` of `public/…` | anyone, signed in or not |
+ * | everything else | a signed-in caller under their own `users/<uid>/` prefix |
+ *
+ * Gating `list` on the prefix is the important half. Enumeration is what turns "keys
+ * are hard to guess" into "keys are known", and it is step one of the attack the
+ * boot guard exists to prevent.
+ *
+ * ## Replace this with your model
+ *
+ * Prefix rules are a starting point, not a general answer: they work for writes
+ * because a write *puts* the object there, but anything already in the bucket needs
+ * the row that owns it consulted. `ctx.data` is handed in for exactly that — trusted,
+ * RLS-bypassing reads, because the hook *is* the authorization decision and running
+ * it through a reader already narrowed by the caller's permissions would be circular:
+ *
+ * ```ts
+ * export const storageAuthorize: StorageAuthorize = async ({ key, user, operation, data }) => {
+ *     if (operation === "read" && isPublicStoragePath(key)) return true;
+ *     if (!user) return false;
+ *     const row = (await data?.collection("attachments").find({
+ *         where: { storage_key: ["==", key] }, limit: 1
+ *     }))?.data?.[0];
+ *     return row?.owner_id === user.uid;
+ * };
+ * ```
+ *
+ * If your bucket really is a public read-only CDN, `storagePublicRead: true` says so
+ * instead. If every signed-in caller is genuinely trusted with every file,
+ * `storageInsecureAllowAnyAuthenticated: true` says *that* — it is named to be read
+ * twice. Both are set on `initializeRebaseBackend` in `index.ts`.
+ */
+export const storageAuthorize: StorageAuthorize = ({ key, user, operation }) => {
+    // The `public/` prefix is the framework's convention for world-readable objects.
+    if (operation === "read" && isPublicStoragePath(key)) {
+        return true;
+    }
+
+    // `user` is null on routes that allow unauthenticated access.
+    if (!user) {
+        return false;
+    }
+
+    // Each caller gets their own namespace. A listing is scoped the same way, so a
+    // prefix outside it — including the empty prefix, which would enumerate the
+    // whole bucket — is denied.
+    return key.startsWith(`users/${user.uid}/`);
+};

package/templates/overlays/baas/rebase.json

@@ -0,0 +1,14 @@
+{
+    "$schema": "https://rebase.pro/schemas/rebase.json",
+    "runtime": "^1",
+    "apps": {
+        "backend": {
+            "type": "backend",
+            "mode": "baas"
+        },
+        "admin": {
+            "type": "admin",
+            "mode": "hosted"
+        }
+    }
+}

package/templates/template/.env.example

@@ -80,12 +80,19 @@ VITE_API_URL=http://localhost:3001
 # ── Storage ───────────────────────────────────────────────────────────────────
 # Set STORAGE_TYPE to choose a storage backend. Default is "local" (filesystem).
 #
-# Supported values: local, s3
+# Supported values: local, s3, gcs
+#
+# In production, "local" means NO file storage: uploads answer
+# 501 STORAGE_NOT_CONFIGURED instead of landing on a container filesystem that
+# is erased on the next redeploy. Configure a bucket below to switch it on, or
+# set FORCE_LOCAL_STORAGE=true if a durable volume really is mounted at
+# STORAGE_PATH (the generated docker-compose.yml does exactly that).
 #
 # STORAGE_TYPE=local
 
 # --- Local filesystem (default — great for dev and single-server deployments) --
 # STORAGE_PATH=./uploads
+# FORCE_LOCAL_STORAGE=true      # Only with a durable volume mounted at STORAGE_PATH
 
 # --- S3-compatible (AWS S3, Cloudflare R2, MinIO, Hetzner Object Storage, Backblaze B2) ---
 # STORAGE_TYPE=s3
@@ -103,9 +110,15 @@ VITE_API_URL=http://localhost:3001
 # S3_ENDPOINT=https://storage.googleapis.com
 # S3_ACCESS_KEY_ID=GOOG...      # HMAC access key
 # S3_SECRET_ACCESS_KEY=...      # HMAC secret
+
+# --- Native GCS (Google Cloud Storage, Firebase Storage) ---
+# STORAGE_TYPE=gcs
+# GCS_BUCKET=my-gcs-bucket
+# GCS_PROJECT_ID=               # Optional — auto-detected from credentials
+# GCS_KEY_FILENAME=             # Omit on GCP: Workload Identity/ADC supplies credentials
 #
-# For native GCS SDK or other providers (Azure Blob, etc.), implement the
-# StorageController interface and pass it directly in your backend config.
+# For other providers (Azure Blob, etc.), implement the StorageController
+# interface and pass it directly in your backend config.
 
 # ── Backups (optional) ────────────────────────────────────────────────────────
 # Manual backups: `rebase db backup --out ./backups` (or an s3://… URL).

package/templates/template/README.md

@@ -4,57 +4,53 @@ A [Rebase](https://rebase.pro) project with a PostgreSQL backend.
 
 ## Quick Start
 
-### Option 1: Docker (recommended for production)
+`rebase init` already generated a `.env` for you with a real `JWT_SECRET`, a
+database password, and a free local database port. **Don't run
+`cp .env.example .env`** — that would overwrite those generated values.
+`.env.example` is a reference for the variables you can set, not a starting
+point for this project.
 
-```bash
-cp .env.example .env
-# Edit .env — set JWT_SECRET and DATABASE_URL (see comments for generators)
-
-docker compose up -d
-```
-
-That's it. Your app is running:
-- **Frontend**: http://localhost (port 80)
-- **Backend API**: http://localhost:3001
-- **PostgreSQL**: localhost:5432
-
-### Option 2: Local Development
-
-#### Prerequisites
+### Prerequisites
 
 - [Node.js](https://nodejs.org) >= 18
 - [pnpm](https://pnpm.io) or [npm](https://www.npmjs.com) (v7+)
-- A PostgreSQL database (you can start the included database container via `docker compose up -d db`)
+- [Docker](https://www.docker.com) (to run the included PostgreSQL container),
+  or your own PostgreSQL database
 
-#### Setup
+### Run it
 
-1. Install dependencies:
+1. Install dependencies (skip if `init` already did this):
 
 ```bash
 pnpm install   # or: npm install
 ```
 
-2. Configure environment:
+2. Start the PostgreSQL database container:
 
 ```bash
-cp .env.example .env
-# Edit .env — set DATABASE_URL, JWT_SECRET
+docker compose up -d db
 ```
 
-3. Generate schema and push to database:
+3. Create the database tables from your collections:
 
 ```bash
-pnpm run schema:generate   # or: npm run schema:generate
-pnpm run db:push            # or: npm run db:push
+pnpm run db:push   # or: npm run db:push
 ```
 
-4. Start the dev server:
+4. Start the dev servers:
 
 ```bash
 pnpm dev   # or: npm run dev
 ```
 
-Backend (Hono + PostgreSQL) on port 3001, frontend (Vite + React) on port 5173.
+Open **http://localhost:5173** — the admin panel. The first account you
+register becomes the admin. The backend API (Hono + PostgreSQL) runs on
+port 3001; the frontend (Vite + React) on port 5173.
+
+> The `db:push` step is what creates the tables for the example `posts`,
+> `authors`, and `tags` collections. Skip it and the admin panel still opens,
+> but those collections will be empty and their API calls will fail until the
+> tables exist.
 
 ## Project Structure
 
@@ -102,12 +98,21 @@ All configuration is managed through a single `.env` file in the project root. B
 - **Frontend**: Vite reads `VITE_*` variables via `envDir` pointing to the project root
 - **Scripts**: load via `dotenv` from the project root
 
-Copy `.env.example` to `.env` to get started. See the comments in `.env.example` for details on each variable.
+`init` already generated your `.env`. See the comments in `.env.example` for details on each variable, and edit `.env` directly to change any of them.
 
 ## Production Deployment
 
+The full stack — PostgreSQL, backend, and frontend — runs from
+`docker compose`. The backend image builds and boots, but it does **not**
+create your collection tables on its own, so push the schema once the
+database is up before (or right after) starting the rest of the stack.
+
 ```bash
-# Build and start
+# 1. Start the database and create the tables from your collections
+docker compose up -d db
+pnpm run db:push        # or: npm run db:push
+
+# 2. Build and start the backend + frontend
 docker compose up -d --build
 
 # View logs
@@ -120,6 +125,11 @@ docker compose down
 docker compose down -v
 ```
 
+> `docker compose` reads the generated `.env` as-is. Set production values
+> (a strong `DATABASE_PASSWORD`, `JWT_SECRET`, storage credentials, …) by
+> editing `.env` directly — see `.env.example` for the full list. Do not
+> `cp .env.example .env`; that discards the values `init` generated.
+
 ## Documentation
 
 - [Rebase Docs](https://rebase.pro/docs)

package/templates/template/backend/src/index.ts

@@ -16,6 +16,7 @@ import {
 } from "@rebasepro/server";
 import { createPostgresDatabaseConnection, createPostgresAdapter } from "@rebasepro/server-postgres";
 import { enums, relations, tables } from "./schema.generated.js";
+import { storageAuthorize } from "../../config/storage.js";
 import { env } from "./env.js";
 import usersCollection from "../../config/collections/users.js";
 
@@ -123,6 +124,12 @@ pass: env.SMTP_PASS! }
                 }
                 : undefined
         },
+        // File storage is opt-in. With no bucket configured, storage is OFF in
+        // production — the upload routes answer 501 STORAGE_NOT_CONFIGURED —
+        // rather than writing to the container filesystem, which is erased on
+        // every restart and redeploy. Uploads that fail loudly are recoverable;
+        // uploads that succeed into a disk about to be wiped are not.
+        // Local disk stays the default in development, where it is what you want.
         storage: env.STORAGE_TYPE === "s3"
             ? {
                 type: "s3",
@@ -133,10 +140,27 @@ pass: env.SMTP_PASS! }
                 endpoint: env.S3_ENDPOINT,
                 forcePathStyle: env.S3_FORCE_PATH_STYLE
             }
-            : {
-                type: "local",
-                basePath: env.STORAGE_PATH || path.resolve(__dirname, "../../uploads")
-            },
+            : env.STORAGE_TYPE === "gcs"
+                ? {
+                    type: "gcs",
+                    bucket: env.GCS_BUCKET!,
+                    projectId: env.GCS_PROJECT_ID,
+                    keyFilename: env.GCS_KEY_FILENAME
+                }
+                // Set FORCE_LOCAL_STORAGE=true only if this deployment really
+                // does have a durable volume mounted at STORAGE_PATH.
+                : isProduction && !env.FORCE_LOCAL_STORAGE
+                    ? undefined
+                    : {
+                        type: "local",
+                        basePath: env.STORAGE_PATH || path.resolve(__dirname, "../../uploads")
+                    },
+        // Storage is not under row-level security, so this hook IS its access
+        // model — the server refuses to boot in production without one, because
+        // "signed in" would otherwise be the only thing between a visitor and
+        // every file in the bucket. See config/storage.ts, which also shows the
+        // multi-tenant (per-owner) shape and the two escape hatches.
+        storageAuthorize,
         history: true
     });
 

package/templates/template/config/admin.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="@rebasepro/admin-types" />
+
+// One line, once per project. `@rebasepro/admin-types` declares the `admin` block on
+// `CollectionConfig` and on every property type by declaration merging, and an
+// augmentation applies to the whole *program* — so this reference is what makes
+// `admin: { … }` legal in every collection file here.
+//
+// A BaaS project has no admin panel and no reason for this file. Without it, `admin` on
+// a collection or a property is a type error, which is the guarantee.

package/templates/template/config/collections/authors.ts

@@ -1,11 +1,10 @@
-import { CollectionConfig } from "@rebasepro/types";
+import type { PostgresCollectionConfig } from "@rebasepro/types";
 
-const authorsCollection: CollectionConfig = {
+const authorsCollection: PostgresCollectionConfig = {
     name: "Authors",
     singularName: "Author",
     slug: "authors",
     table: "authors",
-    icon: "Person",
     properties: {
         id: {
             name: "ID",
@@ -34,12 +33,15 @@ const authorsCollection: CollectionConfig = {
             }
         }
     },
-    propertiesOrder: [
-        "id",
-        "name",
-        "email",
-        "picture"
-    ]
+    admin: {
+        icon: "Person",
+        propertiesOrder: [
+            "id",
+            "name",
+            "email",
+            "picture"
+        ]
+    }
 };
 
 export default authorsCollection;

package/templates/template/config/collections/posts.ts

@@ -1,13 +1,12 @@
-import { CollectionConfig } from "@rebasepro/types";
+import type { PostgresCollectionConfig } from "@rebasepro/types";
 import authorsCollection from "./authors.js";
 import tagsCollection from "./tags.js";
 
-const postsCollection: CollectionConfig = {
+const postsCollection: PostgresCollectionConfig = {
     name: "Posts",
     singularName: "Post",
     slug: "posts",
     table: "posts",
-    icon: "Article",
     properties: {
         id: {
             name: "ID",
@@ -24,7 +23,7 @@ const postsCollection: CollectionConfig = {
         content: {
             name: "Content",
             type: "string",
-            ui: {
+            admin: {
                 markdown: true
             }
         },
@@ -65,6 +64,9 @@ const postsCollection: CollectionConfig = {
             cardinality: "many",
             direction: "owning"
         }
+    },
+    admin: {
+        icon: "Article"
     }
 };