@sansavision/create-pulse 0.4.2 → 0.4.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sansavision/create-pulse",
-  "version": "0.4.2",
+  "version": "0.4.3",
   "description": "Scaffold a new Pulse application",
   "main": "dist/index.js",
   "bin": {

package/templates/nextjs-auth-demo/README.md

@@ -13,26 +13,58 @@ An **investor-ready** demo application showcasing the full capabilities of [Puls
 
 ## Quick Start
 
+### 1. Install dependencies
+
 ```bash
-# 1. Install dependencies
 npm install
+```
 
-# 2. Create .env file
+### 2. Configure environment
+
+```bash
 cp .env.example .env
+```
+
+Edit `.env` and set your secret (generate one with `openssl rand -base64 32`):
+
+```env
+BETTER_AUTH_SECRET=your-generated-secret-here
+BETTER_AUTH_URL=http://localhost:3000
+NEXT_PUBLIC_PULSE_URL=ws://localhost:4001
+```
 
-# 3. Generate a secret and update .env
-openssl rand -base64 32
+> **Note:** `BETTER_AUTH_URL` must match the port your app runs on. If you use `--port 3444`, set it to `http://localhost:3444`.
 
-# 4. Create database tables
-npx @auth/cli migrate
+### 3. Create database tables
 
-# 5. Start the Pulse relay (in another terminal)
-npx @sansavision/pulse-cli serve --auth-mode webhook --auth-webhook http://localhost:3000/api/pulse/verify
+The auth schema is pre-generated in `src/lib/schema.ts`. Push it to SQLite:
 
-# 6. Start the app
+```bash
+npm run db:push
+```
+
+> This creates the `user`, `session`, `account`, and `verification` tables in `./sqlite.db`.
+
+### 4. Start the Pulse relay
+
+In a separate terminal, start the relay with webhook auth:
+
+```bash
+npx @sansavision/pulse-cli serve \
+  --auth-mode webhook \
+  --auth-webhook http://localhost:3000/api/pulse/verify
+```
+
+> If your app runs on a different port, update the `--auth-webhook` URL accordingly.
+
+### 5. Start the app
+
+```bash
 npm run dev
 ```
 
+Open [http://localhost:3000](http://localhost:3000) in your browser.
+
 ## Multi-User Testing
 
 1. Open `http://localhost:3000` in a browser
@@ -70,5 +102,24 @@ Next.js App (port 3000)              Pulse Relay (port 4001)
 | Variable | Description | Default |
 |----------|-------------|---------|
 | `BETTER_AUTH_SECRET` | Auth encryption secret (32+ chars) | — |
-| `BETTER_AUTH_URL` | Base URL of the app | `http://localhost:3000` |
+| `BETTER_AUTH_URL` | Base URL of the app (must match your port) | `http://localhost:3000` |
 | `NEXT_PUBLIC_PULSE_URL` | Pulse relay WebSocket URL | `ws://localhost:4001` |
+
+## Troubleshooting
+
+### "Invalid origin" error on signup
+
+Your `BETTER_AUTH_URL` doesn't match the port the app is running on. For example, if you start the app with `--port 3444`, set `BETTER_AUTH_URL=http://localhost:3444` in `.env`.
+
+### "Connecting to Pulse relay..." stays loading
+
+Make sure the Pulse relay is running in a separate terminal with `--auth-mode webhook`. Without auth flags, the relay won't accept authenticated connections.
+
+### Database errors
+
+If you see table-related errors, re-run the schema push:
+
+```bash
+rm -f sqlite.db
+npm run db:push
+```

package/templates/nextjs-auth-demo/package.json

@@ -7,6 +7,8 @@
     "build": "next build",
     "start": "next start",
     "db:push": "npx drizzle-kit push",
+    "db:generate": "npx drizzle-kit generate",
+    "db:migrate": "npx drizzle-kit migrate",
     "db:studio": "npx drizzle-kit studio"
   },
   "dependencies": {

package/templates/nextjs-auth-demo/src/lib/auth.ts

@@ -2,9 +2,10 @@ import { betterAuth } from "better-auth";
 import { drizzleAdapter } from "better-auth/adapters/drizzle";
 import { bearer } from "better-auth/plugins";
 import { db } from "./db";
+import * as schema from "./schema";
 
 export const auth = betterAuth({
-    database: drizzleAdapter(db, { provider: "sqlite" }),
+    database: drizzleAdapter(db, { provider: "sqlite", schema }),
     emailAndPassword: {
         enabled: true,
     },

package/templates/nextjs-auth-demo/src/lib/db.ts

@@ -1,5 +1,6 @@
 import Database from "better-sqlite3";
 import { drizzle } from "drizzle-orm/better-sqlite3";
+import * as schema from "./schema";
 
 const sqlite = new Database("./sqlite.db");
-export const db = drizzle(sqlite);
+export const db = drizzle(sqlite, { schema });

package/templates/nextjs-auth-demo/src/lib/schema.ts

@@ -0,0 +1,107 @@
+import { relations, sql } from "drizzle-orm";
+import { sqliteTable, text, integer, index } from "drizzle-orm/sqlite-core";
+
+export const user = sqliteTable("user", {
+    id: text("id").primaryKey(),
+    name: text("name").notNull(),
+    email: text("email").notNull().unique(),
+    emailVerified: integer("email_verified", { mode: "boolean" })
+        .default(false)
+        .notNull(),
+    image: text("image"),
+    createdAt: integer("created_at", { mode: "timestamp_ms" })
+        .default(sql`(cast(unixepoch('subsecond') * 1000 as integer))`)
+        .notNull(),
+    updatedAt: integer("updated_at", { mode: "timestamp_ms" })
+        .default(sql`(cast(unixepoch('subsecond') * 1000 as integer))`)
+        .$onUpdate(() => /* @__PURE__ */ new Date())
+        .notNull(),
+});
+
+export const session = sqliteTable(
+    "session",
+    {
+        id: text("id").primaryKey(),
+        expiresAt: integer("expires_at", { mode: "timestamp_ms" }).notNull(),
+        token: text("token").notNull().unique(),
+        createdAt: integer("created_at", { mode: "timestamp_ms" })
+            .default(sql`(cast(unixepoch('subsecond') * 1000 as integer))`)
+            .notNull(),
+        updatedAt: integer("updated_at", { mode: "timestamp_ms" })
+            .$onUpdate(() => /* @__PURE__ */ new Date())
+            .notNull(),
+        ipAddress: text("ip_address"),
+        userAgent: text("user_agent"),
+        userId: text("user_id")
+            .notNull()
+            .references(() => user.id, { onDelete: "cascade" }),
+    },
+    (table) => [index("session_userId_idx").on(table.userId)],
+);
+
+export const account = sqliteTable(
+    "account",
+    {
+        id: text("id").primaryKey(),
+        accountId: text("account_id").notNull(),
+        providerId: text("provider_id").notNull(),
+        userId: text("user_id")
+            .notNull()
+            .references(() => user.id, { onDelete: "cascade" }),
+        accessToken: text("access_token"),
+        refreshToken: text("refresh_token"),
+        idToken: text("id_token"),
+        accessTokenExpiresAt: integer("access_token_expires_at", {
+            mode: "timestamp_ms",
+        }),
+        refreshTokenExpiresAt: integer("refresh_token_expires_at", {
+            mode: "timestamp_ms",
+        }),
+        scope: text("scope"),
+        password: text("password"),
+        createdAt: integer("created_at", { mode: "timestamp_ms" })
+            .default(sql`(cast(unixepoch('subsecond') * 1000 as integer))`)
+            .notNull(),
+        updatedAt: integer("updated_at", { mode: "timestamp_ms" })
+            .$onUpdate(() => /* @__PURE__ */ new Date())
+            .notNull(),
+    },
+    (table) => [index("account_userId_idx").on(table.userId)],
+);
+
+export const verification = sqliteTable(
+    "verification",
+    {
+        id: text("id").primaryKey(),
+        identifier: text("identifier").notNull(),
+        value: text("value").notNull(),
+        expiresAt: integer("expires_at", { mode: "timestamp_ms" }).notNull(),
+        createdAt: integer("created_at", { mode: "timestamp_ms" })
+            .default(sql`(cast(unixepoch('subsecond') * 1000 as integer))`)
+            .notNull(),
+        updatedAt: integer("updated_at", { mode: "timestamp_ms" })
+            .default(sql`(cast(unixepoch('subsecond') * 1000 as integer))`)
+            .$onUpdate(() => /* @__PURE__ */ new Date())
+            .notNull(),
+    },
+    (table) => [index("verification_identifier_idx").on(table.identifier)],
+);
+
+export const userRelations = relations(user, ({ many }) => ({
+    sessions: many(session),
+    accounts: many(account),
+}));
+
+export const sessionRelations = relations(session, ({ one }) => ({
+    user: one(user, {
+        fields: [session.userId],
+        references: [user.id],
+    }),
+}));
+
+export const accountRelations = relations(account, ({ one }) => ({
+    user: one(user, {
+        fields: [account.userId],
+        references: [user.id],
+    }),
+}));