@rebasepro/cli 0.0.1-canary.eae7889 → 0.0.1-canary.eb08332

package/templates/template/README.md

@@ -7,8 +7,8 @@ A [Rebase](https://rebase.pro) project with a PostgreSQL backend.
 ### Option 1: Docker (recommended for production)
 
 ```bash
-cp .env.template .env
-# Edit .env — set POSTGRES_PASSWORD and JWT_SECRET (see comments for generators)
+cp .env.example .env
+# Edit .env — set JWT_SECRET and DATABASE_URL (see comments for generators)
 
 docker compose up -d
 ```
@@ -23,35 +23,35 @@ That's it. Your app is running:
 #### Prerequisites
 
 - [Node.js](https://nodejs.org) >= 18
-- [pnpm](https://pnpm.io)
-- A PostgreSQL database
+- [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`)
 
 #### Setup
 
 1. Install dependencies:
 
 ```bash
-pnpm install
+pnpm install   # or: npm install
 ```
 
 2. Configure environment:
 
 ```bash
-cp .env.template .env
+cp .env.example .env
 # Edit .env — set DATABASE_URL, JWT_SECRET
 ```
 
 3. Generate schema and push to database:
 
 ```bash
-rebase schema generate
-rebase db push
+pnpm run schema:generate   # or: npm run schema:generate
+pnpm run db:push            # or: npm run db:push
 ```
 
 4. Start the dev server:
 
 ```bash
-pnpm dev
+pnpm dev   # or: npm run dev
 ```
 
 Backend (Hono + PostgreSQL) on port 3001, frontend (Vite + React) on port 5173.
@@ -69,7 +69,7 @@ Backend (Hono + PostgreSQL) on port 3001, frontend (Vite + React) on port 5173.
 ├── config/             # Shared collection definitions
 │   └── collections/    # Schema-as-Code TypeScript files
 ├── docker-compose.yml  # Production stack (Postgres + Backend + Frontend)
-├── .env.template       # Environment variable template
+├── .env.example        # Environment variable reference
 └── package.json        # Root workspace config
 ```
 
@@ -94,6 +94,16 @@ Call from the client SDK: `client.call("functions/hello", { name: "World" })`
 
 Collections are defined once in `config/collections/` and used by both the frontend and backend. This ensures your schema stays in sync across the stack.
 
+## Environment Configuration
+
+All configuration is managed through a single `.env` file in the project root. Both the backend and frontend read from this file:
+
+- **Backend**: loads via `dotenv` from `../../.env` (relative to `backend/src/`)
+- **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.
+
 ## Production Deployment
 
 ```bash

package/templates/template/ai-instructions.md

@@ -0,0 +1,17 @@
+# Rebase AI Coding Rules
+
+Rebase provides agent skills for AI coding assistants (Cursor, Claude Code, Windsurf, Gemini CLI, Antigravity, and more) with detailed guidelines, architecture, SDK APIs, and troubleshooting guides.
+
+To install skills for your environment, run:
+
+```
+rebase skills install
+```
+
+## Core Tenets (Quick Reference)
+
+1. **Schema-as-Code**: Always define or edit collections in `config/collections/` (e.g., `config/collections/posts.ts`). Never modify generated Drizzle schemas or PostgreSQL tables manually.
+2. **Two-Step Migrations**:
+   - Step 1: Run `rebase schema generate` to compile collections to the Drizzle schema.
+   - Step 2: Run `rebase db push` (development) or `rebase db generate && rebase db migrate` (production) to apply schema changes to the database.
+3. **Use the SDK**: Always use the Rebase SDK (`rebase.data.<slug>`) to fetch or modify data. Bypassing it with raw SQL or direct Drizzle/PG queries circumvents model validations, lifecycle hooks, and Row-Level Security (RLS).

package/templates/template/backend/Dockerfile

@@ -14,12 +14,12 @@ ENV PATH="$PNPM_HOME:$PATH"
 RUN corepack enable
 
 # Native dependencies for bcrypt, pg, etc.
-RUN apk add --no-cache python3 make g++
+RUN apk add --no-cache python3 make g++ curl ca-certificates
 
 WORKDIR /app
 
 # Copy workspace root files first (cache-friendly layer)
-COPY package.json pnpm-lock.yaml pnpm-workspace.yaml ./
+COPY package.json pnpm-lock.yaml pnpm-workspace.yaml .npmrc ./
 
 # Copy workspace packages
 COPY backend ./backend
@@ -33,7 +33,7 @@ RUN pnpm --filter "*-config" run build
 RUN pnpm --filter "*-backend" run build
 
 # Prune dev dependencies for a smaller runtime
-RUN pnpm install --frozen-lockfile --prod
+RUN CI=true pnpm install --frozen-lockfile --prod
 
 # ── Stage 2: Production Runtime ──────────────────────────────────────
 FROM node:22-alpine AS runtime
@@ -41,6 +41,7 @@ FROM node:22-alpine AS runtime
 ENV PNPM_HOME="/pnpm"
 ENV PATH="$PNPM_HOME:$PATH"
 ENV NODE_ENV=production
+ENV CI=true
 
 RUN corepack enable
 
@@ -50,7 +51,7 @@ RUN addgroup -g 1001 rebase && adduser -u 1001 -G rebase -s /bin/sh -D rebase
 WORKDIR /app
 
 # Copy only production artifacts
-COPY --from=builder /app/package.json /app/pnpm-lock.yaml /app/pnpm-workspace.yaml ./
+COPY --from=builder /app/package.json /app/pnpm-lock.yaml /app/pnpm-workspace.yaml /app/.npmrc ./
 COPY --from=builder /app/node_modules ./node_modules
 COPY --from=builder /app/backend ./backend
 COPY --from=builder /app/config ./config

package/templates/template/backend/functions/hello.ts

@@ -1,6 +1,4 @@
-import { Hono } from "hono";
-import type { HonoEnv } from "@rebasepro/server-core";
-import { rebase } from "@rebasepro/server-core";
+import { defineFunction } from "@rebasepro/server";
 
 /**
  * Example custom function route.
@@ -12,41 +10,47 @@ import { rebase } from "@rebasepro/server-core";
  * Call from the client SDK:
  *   const result = await client.call("functions/hello", { name: "World" });
  *
- * This is a standard Hono app — use any Hono middleware,
- * define any HTTP methods, access the request/response directly.
+ * Authored with `defineFunction`, which hands you a pre-typed Hono app
+ * (so `c.get("user")` / `c.get("driver")` are typed) and the `rebase`
+ * singleton via the injected context — use any Hono middleware, define any
+ * HTTP methods, access the request/response directly.
  *
- * The `rebase` singleton gives you admin-level access to all
- * app-scoped services (data, auth, storage, email) from anywhere.
- * For request-scoped / RLS-scoped access, use c.get("user") and c.get("driver").
+ * `rebase.dataAsAdmin` gives you admin-level access to your data and
+ * **bypasses RLS** — use it only for trusted admin work. For request-scoped /
+ * RLS-scoped data access, use c.get("user") and c.get("driver"), which carry
+ * the caller's identity. (`rebase` also exposes auth, storage, email.)
  */
-const app = new Hono<HonoEnv>();
+export default defineFunction((app, { rebase }) => {
+    void rebase; // available for dataAsAdmin/auth/storage/email — see commented usage below
 
-app.post("/", async (c) => {
-    const body = await c.req.json().catch(() => ({}));
-    const user = c.get("user");
+    app.post("/", async (c) => {
+        const body = await c.req.json().catch(() => ({}));
+        const user = c.get("user");
 
-    const userId = (user && typeof user === "object" && "userId" in user)
-        ? user.userId
-        : "anonymous";
+        const userId = (user && typeof user === "object" && "userId" in user)
+            ? user.userId
+            : "anonymous";
 
-    // Access any Rebase service — just import and use:
-    // await rebase.email?.send({
-    //     to: "admin@example.com",
-    //     subject: "Function called",
-    //     html: `<p>Hello from ${userId}!</p>`,
-    // });
-    //
-    // const authors = await rebase.data.authors.find({ limit: 5 });
+        // Access any Rebase service via the injected `rebase`:
+        // await rebase.email.send({
+        //     to: "admin@example.com",
+        //     subject: "Function called",
+        //     html: `<p>Hello from ${userId}!</p>`,
+        // });
+        //
+        // Admin-scoped data (bypasses RLS — trusted work only):
+        // const authors = await rebase.dataAsAdmin.authors.find({ limit: 5 });
+        // For user-scoped data (RLS applies), use the request-scoped driver
+        // (c.get("driver")), which carries the caller's identity.
 
-    return c.json({
-        message: `Hello, ${body.name || "World"}!`,
-        user: userId
+        return c.json({
+            message: `Hello, ${body.name || "World"}!`,
+            user: userId
+        });
     });
-});
 
-app.get("/", (c) => {
-    return c.json({ status: "ok",
-endpoint: "hello" });
+    app.get("/", (c) => {
+        return c.json({ status: "ok",
+            endpoint: "hello" });
+    });
 });
-
-export default app;

package/templates/template/backend/package.json

@@ -6,26 +6,26 @@
     "type": "module",
     "scripts": {
         "dev": "tsx watch --watch=\"../config/**/*\" src/index.ts",
-        "build": "tsc --noEmit",
-        "start": "tsx src/index.ts"
+        "build": "rebase schema generate --collections ../config/collections && tsc",
+        "start": "node dist/backend/src/index.js"
     },
     "dependencies": {
-        "{{PROJECT_NAME}}-config": "0.0.1",
-        "@rebasepro/server-core": "workspace:*",
-        "@rebasepro/server-postgresql": "workspace:*",
-        "drizzle-orm": "^0.44.4",
-        "hono": "^4.2.0",
-        "@hono/node-server": "^1.11.0",
+        "{{PROJECT_NAME}}-config": "*",
+        "@rebasepro/server": "workspace:*",
+        "@rebasepro/server-postgres": "workspace:*",
+        "@rebasepro/types": "workspace:*",
+        "drizzle-orm": "^0.45.2",
+        "hono": "^4.12.10",
+        "@hono/node-server": "^1.19.12",
         "pg": "^8.11.3",
         "ws": "^8.16.0",
-        "zod": "^3.22.4",
-        "dotenv": "^16.0.0"
+        "dotenv": "^16.0.0",
+        "zod": "^4.4.3"
     },
     "devDependencies": {
         "@types/pg": "^8.6.5",
         "@types/node": "^20.10.5",
         "@types/ws": "^8.5.10",
-        "drizzle-kit": "^0.31.4",
         "tsx": "^4.20.6",
         "typescript": "^5.9.2"
     }

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

@@ -1,52 +1,23 @@
-import { z } from "zod";
 import * as dotenv from "dotenv";
 import path from "path";
 import { fileURLToPath } from "url";
+import { loadEnv } from "@rebasepro/server";
+import { z } from "zod";
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 
 dotenv.config({ path: path.resolve(__dirname, "../../.env") });
 
-const envSchema = z.object({
-    NODE_ENV: z.enum(["development", "production", "test"]).default("development"),
-    PORT: z.string().default("3001").transform(Number),
-    DATABASE_URL: z.string().url("DATABASE_URL must be a valid URL"),
-    ADMIN_CONNECTION_STRING: z.string().url().optional(),
-    JWT_SECRET: z.string().min(32, "JWT_SECRET must be at least 32 characters long"),
-    JWT_ACCESS_EXPIRES_IN: z.string().default("1h"),
-    JWT_REFRESH_EXPIRES_IN: z.string().default("30d"),
-    GOOGLE_CLIENT_ID: z.string().optional(),
-    ALLOW_REGISTRATION: z.enum(["true", "false", ""]).default("false").transform(v => v === "true"),
-    CORS_ORIGINS: z.string().optional(),
-    FRONTEND_URL: z.string().optional(),
-    DB_POOL_MAX: z.string().default("20").transform(Number),
-    DB_POOL_IDLE_TIMEOUT: z.string().default("30000").transform(Number),
-    DB_POOL_CONNECT_TIMEOUT: z.string().default("10000").transform(Number),
-    FORCE_LOCAL_STORAGE: z.enum(["true", "false", ""]).optional().transform(v => v === "true"),
-    STORAGE_TYPE: z.enum(["local", "s3"]).default("local"),
-    STORAGE_PATH: z.string().optional(),
-    S3_BUCKET: z.string().optional(),
-    S3_REGION: z.string().optional(),
-    S3_ACCESS_KEY_ID: z.string().optional(),
-    S3_SECRET_ACCESS_KEY: z.string().optional(),
-    S3_ENDPOINT: z.string().url().optional(),
-    S3_FORCE_PATH_STYLE: z.enum(["true", "false", ""]).optional().transform(v => v === "true"),
-    /**
-     * Service key for admin-level script / server-to-server authentication.
-     * When set, scripts can send `Authorization: Bearer <key>` to get admin access.
-     * Generate with: node -e "console.log(require('crypto').randomBytes(48).toString('base64'))"
-     */
-    REBASE_SERVICE_KEY: z.string().min(32, "REBASE_SERVICE_KEY must be at least 32 characters").optional()
-}).superRefine((data, ctx) => {
-    if (data.NODE_ENV === "production" && !data.CORS_ORIGINS && !data.FRONTEND_URL) {
-        ctx.addIssue({
-            code: z.ZodIssueCode.custom,
-            message: "CORS_ORIGINS or FRONTEND_URL must be set in production to secure the API.",
-            path: ["CORS_ORIGINS"]
-        });
-    }
+export const env = loadEnv({
+    extend: z.object({
+        SMTP_HOST: z.string().optional(),
+        SMTP_PORT: z.string().default("587").transform(Number),
+        SMTP_SECURE: z.enum(["true", "false", ""]).default("false").transform(v => v === "true"),
+        SMTP_USER: z.string().optional(),
+        SMTP_PASS: z.string().optional(),
+        SMTP_FROM: z.string().optional(),
+        SMTP_NAME: z.string().optional(),
+        APP_NAME: z.string().default("Rebase")
+    })
 });
-
-// Parse and export
-export const env = envSchema.parse(process.env);

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

@@ -7,25 +7,36 @@ import path from "path";
 import { fileURLToPath } from "url";
 import {
     initializeRebaseBackend,
+    installShutdownHandlers,
     serveSPA,
     HonoEnv,
     listenWithPortRetry,
     cleanupDevPortFile,
     logger
-} from "@rebasepro/server-core";
-import { createPostgresDatabaseConnection, createPostgresBootstrapper } from "@rebasepro/server-postgresql";
-import { enums, relations, tables } from "./schema.generated";
-import { env } from "./env";
+} from "@rebasepro/server";
+import { createPostgresDatabaseConnection, createPostgresAdapter } from "@rebasepro/server-postgres";
+import { enums, relations, tables } from "./schema.generated.js";
+import { env } from "./env.js";
+import usersCollection from "../../config/collections/users.js";
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 
 // ─── App ─────────────────────────────────────────────────────────────
-const app = new Hono<HonoEnv>();
+const app: Hono<HonoEnv> = new Hono<HonoEnv>();
 
 const isProduction = env.NODE_ENV === "production";
 const allowedOrigins = isProduction
-    ? (env.CORS_ORIGINS || env.FRONTEND_URL || "https://yourdomain.com").split(",").map(s => s.trim())
+    ? (() => {
+        const origins = env.CORS_ORIGINS || env.FRONTEND_URL;
+        if (!origins) {
+            throw new Error(
+                "CORS_ORIGINS or FRONTEND_URL must be set in production. " +
+                "Example: CORS_ORIGINS=https://yourdomain.com"
+            );
+        }
+        return origins.split(",").map(s => s.trim());
+    })()
     : [];
 
 app.use("/*", cors({
@@ -54,26 +65,47 @@ async function startServer() {
         functionsDir: path.resolve(__dirname, "../functions"),
         server,
         app,
-        bootstrappers: [
-            createPostgresBootstrapper({
-                connection: db,
-                schema: { tables,
+        database: createPostgresAdapter({
+            connection: db,
+            schema: { tables,
 enums,
 relations },
-                adminConnectionString: env.ADMIN_CONNECTION_STRING || databaseUrl,
-                connectionString
-            })
-        ],
+            adminConnectionString: env.ADMIN_CONNECTION_STRING || databaseUrl,
+            connectionString
+        }),
         auth: {
+            collection: usersCollection,
             jwtSecret,
             accessExpiresIn: env.JWT_ACCESS_EXPIRES_IN,
             refreshExpiresIn: env.JWT_REFRESH_EXPIRES_IN,
             serviceKey: env.REBASE_SERVICE_KEY,
+            // Cookie-based auth: the refresh token is stored in an httpOnly
+            // cookie (not readable by JS) instead of localStorage, so it is
+            // not exposed to XSS. The frontend opts in via
+            // `authFlowMode: "cookie"` on createRebaseClient. Requires CORS
+            // `credentials: true` (set above).
+            cookieAuth: { sameSite: "Lax" },
             google: env.GOOGLE_CLIENT_ID
                 ? { clientId: env.GOOGLE_CLIENT_ID }
                 : undefined,
-            seedDefaultRoles: true,
-            allowRegistration: env.ALLOW_REGISTRATION
+            allowRegistration: env.ALLOW_REGISTRATION,
+            email: env.SMTP_HOST
+                ? {
+                    from: env.SMTP_FROM || `${env.APP_NAME} <noreply@rebase.pro>`,
+                    smtp: {
+                        host: env.SMTP_HOST,
+                        port: env.SMTP_PORT,
+                        secure: env.SMTP_SECURE,
+                        auth: env.SMTP_USER
+                            ? { user: env.SMTP_USER,
+pass: env.SMTP_PASS! }
+                            : undefined,
+                        name: env.SMTP_NAME
+                    },
+                    appName: env.APP_NAME,
+                    resetPasswordUrl: env.FRONTEND_URL
+                }
+                : undefined
         },
         storage: env.STORAGE_TYPE === "s3"
             ? {
@@ -111,7 +143,7 @@ relations },
     if (!isProduction) {
         // Dev mode: retry the next port if the current one is in use
         const projectRoot = path.resolve(__dirname, "../..");
-        const actualPort = await listenWithPortRetry(server, PORT, { portFileDir: projectRoot });
+        const actualPort = await listenWithPortRetry(server, PORT, { portFileDir: projectRoot, serviceKey: env.REBASE_SERVICE_KEY });
 
         // Clean up port file on exit
         const cleanup = () => cleanupDevPortFile(projectRoot);
@@ -127,17 +159,11 @@ relations },
     }
 
     // ─── Graceful Shutdown ───────────────────────────────────────────────
-    // Uses the framework's built-in shutdown() which drains connections,
-    // stops the cron scheduler, and force-exits after 15s timeout.
-    const gracefulShutdown = async (signal: string) => {
-        logger.info(`Received ${signal}, shutting down...`);
-        await backend.shutdown();
-        await pool.end();
-        logger.info("Database pool closed");
-        process.exit(0);
-    };
-    process.on("SIGTERM", () => gracefulShutdown("SIGTERM"));
-    process.on("SIGINT", () => gracefulShutdown("SIGINT"));
+    // Drains HTTP, stops crons, tears down realtime, then closes the pool.
+    // Guards against double signals and force-exits if shutdown hangs.
+    installShutdownHandlers(backend, {
+        onCleanup: () => pool.end()
+    });
 }
 
 startServer().catch(err => {

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

@@ -1,6 +1,6 @@
-import { EntityCollection } from "@rebasepro/types";
+import { CollectionConfig } from "@rebasepro/types";
 
-const authorsCollection: EntityCollection = {
+const authorsCollection: CollectionConfig = {
     name: "Authors",
     singularName: "Author",
     slug: "authors",

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

@@ -1,5 +1,26 @@
-import postsCollection from "./posts";
-import authorsCollection from "./authors";
-import tagsCollection from "./tags";
+import postsCollection from "./posts.js";
+import authorsCollection from "./authors.js";
+import tagsCollection from "./tags.js";
+import usersCollection from "./users.js";
+import type { SecurityRule } from "@rebasepro/types";
 
-export const collections = [postsCollection, authorsCollection, tagsCollection];
+export const collections = [postsCollection, authorsCollection, tagsCollection, usersCollection];
+
+/**
+ * Applied to any collection in this directory that declares no
+ * `securityRules` of its own: anyone can read, only admins can write.
+ *
+ * These live here, next to the collections, because `rebase db push`
+ * generates the Postgres policies from these files — that is what actually
+ * enforces access. A default declared on the server could never reach the
+ * database.
+ *
+ * A collection that declares neither its own rules nor inherits these is
+ * locked by default: admin-only.
+ */
+export const defaultSecurityRules: SecurityRule[] = [
+    { operation: "select",
+access: "public" },
+    { operations: ["insert", "update", "delete"],
+roles: ["admin"] }
+];

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

@@ -1,8 +1,8 @@
-import { EntityCollection } from "@rebasepro/types";
-import authorsCollection from "./authors";
-import tagsCollection from "./tags";
+import { CollectionConfig } from "@rebasepro/types";
+import authorsCollection from "./authors.js";
+import tagsCollection from "./tags.js";
 
-const postsCollection: EntityCollection = {
+const postsCollection: CollectionConfig = {
     name: "Posts",
     singularName: "Post",
     slug: "posts",
@@ -12,9 +12,7 @@ const postsCollection: EntityCollection = {
         id: {
             name: "ID",
             type: "number",
-            validation: {
-                required: true
-            }
+            isId: "increment"
         },
         title: {
             name: "Title",
@@ -26,7 +24,9 @@ const postsCollection: EntityCollection = {
         content: {
             name: "Content",
             type: "string",
-            multiline: true
+            ui: {
+                markdown: true
+            }
         },
         status: {
             name: "Status",
@@ -35,57 +35,37 @@ const postsCollection: EntityCollection = {
                 {
                     id: "draft",
                     label: "Draft",
-                    color: "grayLight"
+                    color: "gray"
                 },
                 {
                     id: "review",
                     label: "In Review",
-                    color: "orangeLight"
+                    color: "orange"
                 },
                 {
                     id: "published",
                     label: "Published",
-                    color: "greenLight"
+                    color: "green"
                 }
             ]
         },
         author: {
             name: "Author",
             type: "relation",
-            relationName: "author",
-            relation: {
-                relationName: "author",
-                cardinality: "one",
-                direction: "owning",
-                target: () => authorsCollection
-            }
-        },
-        tags: {
-            name: "Tags",
-            type: "relation",
-            relationName: "tags",
-            relation: {
-                relationName: "tags",
-                cardinality: "many",
-                direction: "owning",
-                target: () => tagsCollection
-            }
-        }
-    },
-    relations: [
-        {
             relationName: "author",
             target: () => authorsCollection,
             cardinality: "one",
             direction: "owning"
         },
-        {
+        tags: {
+            name: "Tags",
+            type: "relation",
             relationName: "tags",
             target: () => tagsCollection,
             cardinality: "many",
             direction: "owning"
         }
-    ]
+    }
 };
 
 export default postsCollection;

package/templates/template/config/collections/presets/blank/index.ts

@@ -0,0 +1,3 @@
+import usersCollection from "../../users.js";
+
+export const collections = [usersCollection];

package/templates/template/config/collections/presets/ecommerce/categories.ts

@@ -0,0 +1,40 @@
+import { CollectionConfig } from "@rebasepro/types";
+
+const categoriesCollection: CollectionConfig = {
+    name: "Categories",
+    singularName: "Category",
+    slug: "categories",
+    table: "categories",
+    icon: "Category",
+    properties: {
+        id: {
+            name: "ID",
+            type: "number",
+            isId: "increment"
+        },
+        name: {
+            name: "Name",
+            type: "string",
+            validation: { required: true }
+        },
+        slug: {
+            name: "Slug",
+            type: "string",
+            validation: { required: true }
+        },
+        description: {
+            name: "Description",
+            type: "string",
+            ui: {
+                multiline: true
+            }
+        },
+        icon: {
+            name: "Icon",
+            type: "string"
+        }
+    },
+    propertiesOrder: ["id", "name", "slug", "description", "icon"]
+};
+
+export default categoriesCollection;

package/templates/template/config/collections/presets/ecommerce/index.ts

@@ -0,0 +1,6 @@
+import productsCollection from "./products.js";
+import categoriesCollection from "./categories.js";
+import ordersCollection from "./orders.js";
+import usersCollection from "../../users.js";
+
+export const collections = [productsCollection, categoriesCollection, ordersCollection, usersCollection];