@primstack/cli 0.0.1

package/dist/templates/fullstack/shared/src/schemas/index.ts.template

@@ -0,0 +1,8 @@
+export * from './user.js';
+export * from './organization.js';
+export * from './membership.js';
+export * from './plan.js';
+export * from './subscription.js';
+export * from './invite.js';
+export * from './api-key.js';
+export * from './audit-log.js';

package/dist/templates/fullstack/shared/src/schemas/invite.ts.template

@@ -0,0 +1,25 @@
+import { z } from 'zod';
+
+export const inviteRoleSchema = z.enum(['admin', 'member']);
+
+export const inviteSchema = z.object({
+  id: z.string().uuid(),
+  email: z.string().email(),
+  organizationId: z.string().uuid(),
+  role: inviteRoleSchema,
+  token: z.string().min(32),
+  expiresAt: z.coerce.date(),
+  acceptedAt: z.coerce.date().nullable(),
+  createdAt: z.coerce.date(),
+});
+
+export const createInviteSchema = inviteSchema.omit({
+  id: true,
+  token: true,
+  acceptedAt: true,
+  createdAt: true,
+});
+
+export const acceptInviteSchema = z.object({
+  token: z.string(),
+});

package/dist/templates/fullstack/shared/src/schemas/membership.ts.template

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+
+export const memberRoleSchema = z.enum(['owner', 'admin', 'member']);
+
+export const membershipSchema = z.object({
+  id: z.string().uuid(),
+  userId: z.string().uuid(),
+  organizationId: z.string().uuid(),
+  role: memberRoleSchema,
+  createdAt: z.coerce.date(),
+});
+
+export const createMembershipSchema = membershipSchema.omit({
+  id: true,
+  createdAt: true,
+});
+
+export const updateMembershipSchema = z.object({
+  role: memberRoleSchema,
+});

package/dist/templates/fullstack/shared/src/schemas/organization.ts.template

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+
+export const organizationSchema = z.object({
+  id: z.string().uuid(),
+  name: z.string().min(1).max(255),
+  slug: z.string().regex(/^[a-z0-9-]+$/, 'Slug must be lowercase alphanumeric with hyphens'),
+  logoUrl: z.string().url().nullable(),
+  createdAt: z.coerce.date(),
+  updatedAt: z.coerce.date(),
+});
+
+export const createOrganizationSchema = organizationSchema.omit({
+  id: true,
+  createdAt: true,
+  updatedAt: true,
+});
+
+export const updateOrganizationSchema = createOrganizationSchema.partial();

package/dist/templates/fullstack/shared/src/schemas/plan.ts.template

@@ -0,0 +1,38 @@
+import { z } from 'zod';
+
+export const planLimitsSchema = z.object({
+  seats: z.number().int().nullable(),
+  storage: z.number().int().nullable(), // bytes
+  apiCalls: z.number().int().nullable(),
+});
+
+export const planSchema = z.object({
+  id: z.string().uuid(),
+  name: z.string().min(1),
+  slug: z.string().regex(/^[a-z0-9-]+$/),
+  description: z.string().nullable(),
+  priceMonthly: z.number().int(), // cents
+  priceYearly: z.number().int(),  // cents
+  features: z.array(z.string()),
+  limits: planLimitsSchema,
+  isActive: z.boolean().default(true),
+
+  // Stripe integration fields
+  stripeProductIdTest: z.string().nullable().optional(),
+  stripeProductIdLive: z.string().nullable().optional(),
+  currentPriceLookupKeyMonthly: z.string().nullable().optional(), // e.g., 'pro_monthly_v2'
+  currentPriceLookupKeyYearly: z.string().nullable().optional(),
+
+  createdAt: z.coerce.date(),
+  updatedAt: z.coerce.date(),
+});
+
+export const createPlanSchema = planSchema.omit({
+  id: true,
+  createdAt: true,
+  updatedAt: true,
+}).extend({
+  isActive: z.boolean().optional(),
+});
+
+export const updatePlanSchema = createPlanSchema.partial();

package/dist/templates/fullstack/shared/src/schemas/subscription.ts.template

@@ -0,0 +1,56 @@
+import { z } from 'zod';
+
+export const subscriptionStatusSchema = z.enum(['active', 'canceled', 'past_due', 'trialing', 'incomplete']);
+export const billingIntervalSchema = z.enum(['monthly', 'yearly']);
+
+export const subscriptionSchema = z.object({
+  id: z.string().uuid(),
+  organizationId: z.string().uuid(),
+  planId: z.string().uuid(),
+  status: subscriptionStatusSchema,
+  currentPeriodStart: z.coerce.date(),
+  currentPeriodEnd: z.coerce.date(),
+  cancelAtPeriodEnd: z.boolean().default(false),
+
+  // Stripe integration fields
+  stripeSubscriptionId: z.string().nullable().optional(),
+  stripeCustomerId: z.string().nullable().optional(),
+
+  // Price versioning (locks in the price at subscription time)
+  billingInterval: billingIntervalSchema.nullable().optional(),
+  priceLookupKey: z.string().nullable().optional(), // e.g., 'pro_monthly_v1'
+  priceVersion: z.number().int().nullable().optional(),
+  priceAmountCents: z.number().int().nullable().optional(), // Locked-in price
+
+  // Trial support
+  trialStart: z.coerce.date().nullable().optional(),
+  trialEnd: z.coerce.date().nullable().optional(),
+
+  canceledAt: z.coerce.date().nullable().optional(),
+  createdAt: z.coerce.date(),
+  updatedAt: z.coerce.date(),
+});
+
+export const createSubscriptionSchema = subscriptionSchema.omit({
+  id: true,
+  createdAt: true,
+  updatedAt: true,
+}).extend({
+  cancelAtPeriodEnd: z.boolean().optional(),
+});
+
+export const updateSubscriptionSchema = z.object({
+  status: subscriptionStatusSchema.optional(),
+  currentPeriodStart: z.coerce.date().optional(),
+  currentPeriodEnd: z.coerce.date().optional(),
+  cancelAtPeriodEnd: z.boolean().optional(),
+  stripeSubscriptionId: z.string().nullable().optional(),
+  stripeCustomerId: z.string().nullable().optional(),
+  billingInterval: billingIntervalSchema.nullable().optional(),
+  priceLookupKey: z.string().nullable().optional(),
+  priceVersion: z.number().int().nullable().optional(),
+  priceAmountCents: z.number().int().nullable().optional(),
+  trialStart: z.coerce.date().nullable().optional(),
+  trialEnd: z.coerce.date().nullable().optional(),
+  canceledAt: z.coerce.date().nullable().optional(),
+});

package/dist/templates/fullstack/shared/src/schemas/user.ts.template

@@ -0,0 +1,21 @@
+import { z } from 'zod';
+
+export const userSchema = z.object({
+  id: z.string().uuid(),
+  email: z.string().email(),
+  name: z.string().nullable(),
+  avatarUrl: z.string().url().nullable(),
+  emailVerified: z.boolean().default(false),
+  createdAt: z.coerce.date(),
+  updatedAt: z.coerce.date(),
+});
+
+export const createUserSchema = userSchema.omit({
+  id: true,
+  createdAt: true,
+  updatedAt: true,
+}).extend({
+  emailVerified: z.boolean().optional(),
+});
+
+export const updateUserSchema = createUserSchema.partial();

package/dist/templates/fullstack/shared/src/types/index.ts.template

@@ -0,0 +1,75 @@
+import { z } from 'zod';
+import {
+  userSchema,
+  createUserSchema,
+  updateUserSchema,
+  organizationSchema,
+  createOrganizationSchema,
+  updateOrganizationSchema,
+  membershipSchema,
+  createMembershipSchema,
+  updateMembershipSchema,
+  memberRoleSchema,
+  planSchema,
+  createPlanSchema,
+  updatePlanSchema,
+  planLimitsSchema,
+  subscriptionSchema,
+  createSubscriptionSchema,
+  updateSubscriptionSchema,
+  subscriptionStatusSchema,
+  inviteSchema,
+  createInviteSchema,
+  acceptInviteSchema,
+  inviteRoleSchema,
+  apiKeySchema,
+  createApiKeySchema,
+  apiKeyWithSecretSchema,
+  updateApiKeySchema,
+  auditLogSchema,
+  createAuditLogSchema,
+} from '../schemas/index.js';
+
+// User types
+export type User = z.infer<typeof userSchema>;
+export type CreateUser = z.infer<typeof createUserSchema>;
+export type UpdateUser = z.infer<typeof updateUserSchema>;
+
+// Organization types
+export type Organization = z.infer<typeof organizationSchema>;
+export type CreateOrganization = z.infer<typeof createOrganizationSchema>;
+export type UpdateOrganization = z.infer<typeof updateOrganizationSchema>;
+
+// Membership types
+export type Membership = z.infer<typeof membershipSchema>;
+export type CreateMembership = z.infer<typeof createMembershipSchema>;
+export type UpdateMembership = z.infer<typeof updateMembershipSchema>;
+export type MemberRole = z.infer<typeof memberRoleSchema>;
+
+// Plan types
+export type Plan = z.infer<typeof planSchema>;
+export type CreatePlan = z.infer<typeof createPlanSchema>;
+export type UpdatePlan = z.infer<typeof updatePlanSchema>;
+export type PlanLimits = z.infer<typeof planLimitsSchema>;
+
+// Subscription types
+export type Subscription = z.infer<typeof subscriptionSchema>;
+export type CreateSubscription = z.infer<typeof createSubscriptionSchema>;
+export type UpdateSubscription = z.infer<typeof updateSubscriptionSchema>;
+export type SubscriptionStatus = z.infer<typeof subscriptionStatusSchema>;
+
+// Invite types
+export type Invite = z.infer<typeof inviteSchema>;
+export type CreateInvite = z.infer<typeof createInviteSchema>;
+export type AcceptInvite = z.infer<typeof acceptInviteSchema>;
+export type InviteRole = z.infer<typeof inviteRoleSchema>;
+
+// ApiKey types
+export type ApiKey = z.infer<typeof apiKeySchema>;
+export type CreateApiKey = z.infer<typeof createApiKeySchema>;
+export type ApiKeyWithSecret = z.infer<typeof apiKeyWithSecretSchema>;
+export type UpdateApiKey = z.infer<typeof updateApiKeySchema>;
+
+// AuditLog types
+export type AuditLog = z.infer<typeof auditLogSchema>;
+export type CreateAuditLog = z.infer<typeof createAuditLogSchema>;

package/dist/templates/fullstack/shared/src/validators/index.ts.template

@@ -0,0 +1,53 @@
+import { z } from 'zod';
+
+// Email validation
+export function isValidEmail(email: string): boolean {
+  return z.string().email().safeParse(email).success;
+}
+
+// UUID validation
+export function isValidUuid(id: string): boolean {
+  return z.string().uuid().safeParse(id).success;
+}
+
+// Slug validation (lowercase alphanumeric with hyphens)
+export function isValidSlug(slug: string): boolean {
+  return /^[a-z0-9-]+$/.test(slug);
+}
+
+// URL validation
+export function isValidUrl(url: string): boolean {
+  return z.string().url().safeParse(url).success;
+}
+
+// Parse and validate with a schema, returns typed result or throws
+export function parseOrThrow<T extends z.ZodSchema>(
+  schema: T,
+  data: unknown
+): z.infer<T> {
+  return schema.parse(data);
+}
+
+// Safe parse with a schema, returns { success, data, error }
+export function safeParse<T extends z.ZodSchema>(
+  schema: T,
+  data: unknown
+): z.SafeParseReturnType<unknown, z.infer<T>> {
+  return schema.safeParse(data);
+}
+
+// Validate pagination params
+export const paginationSchema = z.object({
+  page: z.coerce.number().int().min(1).default(1),
+  limit: z.coerce.number().int().min(1).max(100).default(20),
+});
+
+export type Pagination = z.infer<typeof paginationSchema>;
+
+// Validate sort params
+export function createSortSchema<T extends string>(allowedFields: readonly T[]) {
+  return z.object({
+    sortBy: z.enum(allowedFields as unknown as [T, ...T[]]).optional(),
+    sortOrder: z.enum(['asc', 'desc']).default('asc'),
+  });
+}

package/dist/templates/fullstack/shared/tsconfig.json.template

@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "lib": ["ES2022"],
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "declaration": true,
+    "declarationMap": true,
+    "outDir": "./dist",
+    "rootDir": "./src"
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}

package/dist/templates/fullstack/web/.gitignore.template

@@ -0,0 +1,3 @@
+node_modules/
+dist/
+*.log

package/dist/templates/fullstack/web/index.html.template

@@ -0,0 +1,13 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <link rel="icon" type="image/svg+xml" href="/vite.svg" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>{{PROJECT_NAME}}</title>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/src/main.tsx"></script>
+  </body>
+</html>

package/dist/templates/fullstack/web/package.json.template

@@ -0,0 +1,23 @@
+{
+  "name": "@{{PROJECT_NAME}}/web",
+  "version": "0.0.1",
+  "type": "module",
+  "scripts": {
+    "dev": "vite",
+    "build": "tsc && vite build",
+    "preview": "vite preview",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@{{PROJECT_NAME}}/shared": "workspace:*",
+    "react": "^18.3.0",
+    "react-dom": "^18.3.0"
+  },
+  "devDependencies": {
+    "@types/react": "^18.3.0",
+    "@types/react-dom": "^18.3.0",
+    "@vitejs/plugin-react": "^4.3.0",
+    "typescript": "^5.7.0",
+    "vite": "^5.4.0"
+  }
+}

package/dist/templates/fullstack/web/src/App.tsx.template

@@ -0,0 +1,47 @@
+import { useState, useEffect } from 'react';
+import type { User } from '@{{PROJECT_NAME}}/shared';
+
+function App() {
+  const [health, setHealth] = useState<{ status: string; timestamp: string } | null>(null);
+
+  useEffect(() => {
+    fetch('/api/health')
+      .then((res) => res.json())
+      .then(setHealth)
+      .catch(console.error);
+  }, []);
+
+  // Example: Type-safe user display (types from shared package)
+  const exampleUser: Partial<User> = {
+    email: 'user@example.com',
+    name: 'Example User',
+  };
+
+  return (
+    <div className="app">
+      <header>
+        <h1>{{PROJECT_NAME}}</h1>
+        <p>Fullstack app with shared types</p>
+      </header>
+
+      <main>
+        <section>
+          <h2>API Health</h2>
+          {health ? (
+            <pre>{JSON.stringify(health, null, 2)}</pre>
+          ) : (
+            <p>Loading...</p>
+          )}
+        </section>
+
+        <section>
+          <h2>Type-Safe User Example</h2>
+          <p>Types imported from @{{PROJECT_NAME}}/shared</p>
+          <pre>{JSON.stringify(exampleUser, null, 2)}</pre>
+        </section>
+      </main>
+    </div>
+  );
+}
+
+export default App;

package/dist/templates/fullstack/web/src/index.css.template

@@ -0,0 +1,54 @@
+* {
+  box-sizing: border-box;
+  margin: 0;
+  padding: 0;
+}
+
+body {
+  font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen,
+    Ubuntu, Cantarell, 'Open Sans', 'Helvetica Neue', sans-serif;
+  line-height: 1.6;
+  color: #333;
+  background: #f5f5f5;
+}
+
+.app {
+  max-width: 800px;
+  margin: 0 auto;
+  padding: 2rem;
+}
+
+header {
+  margin-bottom: 2rem;
+}
+
+header h1 {
+  font-size: 2rem;
+  margin-bottom: 0.5rem;
+}
+
+header p {
+  color: #666;
+}
+
+section {
+  background: white;
+  border-radius: 8px;
+  padding: 1.5rem;
+  margin-bottom: 1.5rem;
+  box-shadow: 0 1px 3px rgba(0, 0, 0, 0.1);
+}
+
+section h2 {
+  font-size: 1.25rem;
+  margin-bottom: 1rem;
+  color: #444;
+}
+
+pre {
+  background: #f8f8f8;
+  padding: 1rem;
+  border-radius: 4px;
+  overflow-x: auto;
+  font-size: 0.875rem;
+}

package/dist/templates/fullstack/web/src/main.tsx.template

@@ -0,0 +1,10 @@
+import { StrictMode } from 'react';
+import { createRoot } from 'react-dom/client';
+import App from './App';
+import './index.css';
+
+createRoot(document.getElementById('root')!).render(
+  <StrictMode>
+    <App />
+  </StrictMode>
+);

package/dist/templates/fullstack/web/src/vite-env.d.ts.template

@@ -0,0 +1 @@
+/// <reference types="vite/client" />

package/dist/templates/fullstack/web/tsconfig.json.template

@@ -0,0 +1,21 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "useDefineForClassFields": true,
+    "lib": ["ES2022", "DOM", "DOM.Iterable"],
+    "module": "ESNext",
+    "skipLibCheck": true,
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "noEmit": true,
+    "jsx": "react-jsx",
+    "strict": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noFallthroughCasesInSwitch": true
+  },
+  "include": ["src"],
+  "references": [{ "path": "./tsconfig.node.json" }]
+}

package/dist/templates/fullstack/web/tsconfig.node.json.template

@@ -0,0 +1,11 @@
+{
+  "compilerOptions": {
+    "composite": true,
+    "skipLibCheck": true,
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "allowSyntheticDefaultImports": true,
+    "strict": true
+  },
+  "include": ["vite.config.ts"]
+}

package/dist/templates/fullstack/web/vite.config.ts.template

@@ -0,0 +1,15 @@
+import { defineConfig } from 'vite';
+import react from '@vitejs/plugin-react';
+
+export default defineConfig({
+  plugins: [react()],
+  server: {
+    port: 5173,
+    proxy: {
+      '/api': {
+        target: 'http://localhost:{{API_PORT}}',
+        changeOrigin: true,
+      },
+    },
+  },
+});

package/dist/templates/hosted/root/.env.local.template

@@ -0,0 +1,13 @@
+# Auth.js (auto-generated secret — replace if needed)
+AUTH_SECRET={{AUTH_SECRET}}
+AUTH_URL=http://localhost:3000
+
+# GitHub OAuth (create app at https://github.com/settings/developers)
+# Set callback URL to: http://localhost:3000/api/auth/callback/github
+GITHUB_CLIENT_ID=
+GITHUB_CLIENT_SECRET=
+
+# Stripe (optional — add via `prim integrations add stripe`)
+# STRIPE_SECRET_KEY=sk_test_...
+# STRIPE_WEBHOOK_SECRET=whsec_...
+# NEXT_PUBLIC_STRIPE_PUBLISHABLE_KEY=pk_test_...

package/dist/templates/hosted/root/.gitignore.template

@@ -0,0 +1,32 @@
+# dependencies
+node_modules/
+.pnp
+.pnp.js
+
+# next.js
+.next/
+out/
+
+# production
+build/
+dist/
+
+# env files
+.env
+.env.local
+.env.*.local
+
+# misc
+.DS_Store
+*.pem
+*.log
+
+# local db
+local.db
+local.db-journal
+
+# turbo
+.turbo
+
+# vercel
+.vercel