@percepta/create 3.1.4 → 3.2.0

package/templates/webapp/src/server/trpc.ts

@@ -1,8 +1,17 @@
+import type { PermissionClient, SubjectRef } from "@percepta/access-control";
+import {
+  createRequireApplicationAccess,
+  createRequirePermission,
+} from "@percepta/access-control/trpc";
 import { TRPCError, initTRPC } from "@trpc/server";
-import { headers } from "next/headers";
 import superjson from "superjson";
-import { type BetterAuthSession, auth } from "../lib/auth";
+import { accessManifest } from "../access/access.manifest";
+import { type BetterAuthSession, getServerSession } from "../lib/auth";
 import { AuthContextService } from "../services/AuthContextService";
+import {
+  getAccessControl,
+  toUserSubject,
+} from "../services/access/AppAccessControl";
 import { getTracer } from "../services/logger/AppLogger";
 
 export interface Context {
@@ -16,16 +25,23 @@ export interface ProtectedContext extends Context {
   session: BetterAuthSession;
 }
 
-export async function createContext(): Promise<Context> {
-  const session = await auth.api.getSession({
-    headers: await headers(),
-  });
+const lazyPermissionClient = {
+  can(check) {
+    return getAccessControl().permissions.can(check);
+  },
+} satisfies Pick<PermissionClient, "can">;
 
+function getCurrentSubject(ctx: Context): SubjectRef | null {
+  const userId = ctx.session?.user.id;
+  return userId == null ? null : toUserSubject(userId);
+}
+
+export async function createContext(): Promise<Context> {
   const services: Context["services"] = {
     authContext: AuthContextService.create(),
   };
 
-  return { session, services };
+  return { session: await getServerSession(), services };
 }
 
 export const { router, procedure } = initTRPC.context<Context>().create({
@@ -42,7 +58,7 @@ export const { router, procedure } = initTRPC.context<Context>().create({
   },
 });
 
-export const protectedProcedure = procedure.use(
+const requireAuthenticatedUser = procedure.use(
   ({ ctx, next }): ReturnType<typeof next<ProtectedContext>> => {
     const {
       session,
@@ -59,3 +75,21 @@ export const protectedProcedure = procedure.use(
     );
   },
 );
+
+const requireApplicationAccess =
+  createRequireApplicationAccess<ProtectedContext>({
+    accessControl: lazyPermissionClient,
+    getSubject: getCurrentSubject,
+    manifest: accessManifest,
+  });
+
+export const requirePermission = createRequirePermission<ProtectedContext>({
+  accessControl: lazyPermissionClient,
+  getSubject: getCurrentSubject,
+});
+
+export const protectedProcedure = requireAuthenticatedUser;
+
+export const appProcedure = requireAuthenticatedUser.use(
+  requireApplicationAccess,
+);

package/templates/webapp/src/services/DatabaseService.ts

@@ -1,7 +1,6 @@
 import { AsyncLocalStorage } from "node:async_hooks";
 import { type NodePgDatabase } from "drizzle-orm/node-postgres";
 import { db } from "../drizzle/db";
-import type * as schema from "../drizzle/schema";
 
 export class DatabaseService {
   private static SINGLETON: DatabaseService | undefined;
@@ -15,10 +14,10 @@ export class DatabaseService {
 
   private transactionAsyncLocalStorage = new AsyncLocalStorage<LocalStorage>();
 
-  private constructor(private database: NodePgDatabase<typeof schema>) {}
+  private constructor(private database: NodePgDatabase) {}
 
   public async createTransaction<TReturn>(
-    callback: (txn: NodePgDatabase<typeof schema>) => Promise<TReturn>,
+    callback: (txn: NodePgDatabase) => Promise<TReturn>,
   ): Promise<TReturn> {
     const currentContext = this.transactionAsyncLocalStorage.getStore();
     if (currentContext != null) {
@@ -47,8 +46,8 @@ export class DatabaseService {
   }
 }
 
-type Database = Omit<NodePgDatabase<typeof schema>, "transaction">;
+type Database = Omit<NodePgDatabase, "transaction">;
 
 interface LocalStorage {
-  txn: NodePgDatabase<typeof schema>;
+  txn: NodePgDatabase;
 }

package/templates/webapp/src/services/access/AppAccessControl.ts

@@ -0,0 +1,39 @@
+import {
+  type AppAccessRuntime,
+  createAppAccessRuntime,
+} from "@percepta/access-control";
+import { accessManifest } from "../../access/access.manifest";
+import { getEnvConfig } from "../../config/getEnvConfig";
+
+export type AppAccessControl = AppAccessRuntime<typeof accessManifest>;
+
+const appAccessRuntime = createAppAccessRuntime({
+  manifest: accessManifest,
+  spicedb: () => {
+    const {
+      NODE_ENV: nodeEnv,
+      SPICEDB_ENDPOINT: endpoint,
+      SPICEDB_INSECURE: insecure,
+      SPICEDB_PRESHARED_KEY: presharedKey,
+    } = getEnvConfig();
+
+    return {
+      endpoint,
+      insecure,
+      nodeEnv,
+      presharedKey,
+    };
+  },
+});
+
+export function canAccessApplication(userId: string): Promise<boolean> {
+  return appAccessRuntime.canAccessApplication(userId);
+}
+
+export function getAccessControl(): AppAccessControl {
+  return appAccessRuntime.getAccessControl();
+}
+
+export function toUserSubject(userId: string) {
+  return appAccessRuntime.toUserSubject(userId);
+}

package/dist/chunk-CO3YWUD6.js

@@ -1,139 +0,0 @@
-// src/utils/prompts.ts
-import path from "path";
-import inquirer from "inquirer";
-
-// src/utils/validate.ts
-import validateNpmPackageName from "validate-npm-package-name";
-function validateProjectName(name) {
-  const result = validateNpmPackageName(name);
-  if (!result.validForNewPackages) {
-    const errors = [...result.errors || [], ...result.warnings || []];
-    return {
-      valid: false,
-      error: errors[0] || "Invalid package name"
-    };
-  }
-  return { valid: true };
-}
-
-// src/utils/case-converters.ts
-function toKebabCase(str) {
-  return str.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
-}
-function toTitleCase(str) {
-  return str.split("-").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
-}
-function toSnakeCase(str) {
-  return str.replace(/-/g, "_");
-}
-
-// src/utils/prompts.ts
-var VALID_PROJECT_TYPES = ["monorepo", "webapp", "library"];
-function isValidProjectType(value) {
-  return typeof value === "string" && VALID_PROJECT_TYPES.includes(value);
-}
-async function promptName(message) {
-  const { name } = await inquirer.prompt([
-    {
-      type: "input",
-      name: "name",
-      message,
-      filter: toKebabCase,
-      validate: (input) => {
-        const result = validateProjectName(toKebabCase(input));
-        return result.valid || result.error || "Invalid project name";
-      }
-    }
-  ]);
-  return name;
-}
-async function promptOutsideMonorepoType() {
-  const { webapp } = await inquirer.prompt([
-    {
-      type: "confirm",
-      name: "webapp",
-      message: "Initialize with a webapp?",
-      default: true
-    }
-  ]);
-  return webapp ? "webapp" : "monorepo";
-}
-async function promptInsideMonorepoType() {
-  const { projectType } = await inquirer.prompt([
-    {
-      type: "rawlist",
-      name: "projectType",
-      message: "What kind of package?",
-      // inquirer v12 / @inquirer/rawlist v5 matches `default` against the
-      // choice's `value`, not its index. `default: 0` would be a no-op.
-      default: "webapp",
-      choices: [
-        { name: "Webapp  \u2014 A Next.js webapp", value: "webapp" },
-        { name: "Library \u2014 A TypeScript library", value: "library" }
-      ]
-    }
-  ]);
-  return projectType;
-}
-async function promptProjectDetails(defaults) {
-  const inMonorepo = defaults.monorepoContext?.found ?? false;
-  const cwd = defaults.cwd ?? process.cwd();
-  let projectType;
-  let finalName;
-  if (inMonorepo) {
-    projectType = defaults.projectType ?? await promptInsideMonorepoType();
-    await defaults.beforeNamePrompt?.(projectType);
-    finalName = defaults.name || await promptName("Package name?");
-  } else {
-    const repoName = defaults.repoName || (defaults.projectType === "monorepo" ? defaults.name : void 0) || await promptName("Repo name?");
-    const repoTitle = toTitleCase(repoName);
-    projectType = defaults.projectType ?? await promptOutsideMonorepoType();
-    await defaults.beforeNamePrompt?.(projectType);
-    if (projectType === "monorepo") {
-      finalName = repoName;
-      const finalTitle3 = repoTitle;
-      const finalDirectory3 = path.resolve(cwd, repoName);
-      return {
-        projectType,
-        directory: finalDirectory3,
-        name: finalName,
-        title: finalTitle3,
-        installDeps: !defaults.skipInstall,
-        monorepoName: repoName,
-        monorepoTitle: repoTitle
-      };
-    }
-    const packageNamePrompt = projectType === "webapp" ? "Webapp name?" : "Library name?";
-    finalName = defaults.name || await promptName(packageNamePrompt);
-    const finalTitle2 = toTitleCase(finalName);
-    const finalDirectory2 = path.resolve(cwd, repoName);
-    return {
-      projectType,
-      directory: finalDirectory2,
-      name: finalName,
-      title: finalTitle2,
-      installDeps: !defaults.skipInstall,
-      monorepoName: repoName,
-      monorepoTitle: repoTitle
-    };
-  }
-  const finalTitle = finalName ? toTitleCase(finalName) : "";
-  const finalDirectory = !inMonorepo && finalName ? path.resolve(cwd, finalName) : "";
-  return {
-    projectType,
-    directory: finalDirectory,
-    name: finalName,
-    title: finalTitle,
-    installDeps: !defaults.skipInstall
-  };
-}
-
-export {
-  validateProjectName,
-  toKebabCase,
-  toTitleCase,
-  toSnakeCase,
-  VALID_PROJECT_TYPES,
-  isValidProjectType,
-  promptProjectDetails
-};

package/dist/chunk-DCM7JOSC.js

@@ -1,49 +0,0 @@
-// src/utils/git-ops.ts
-import { execFileSync } from "child_process";
-function toGitPath(p) {
-  return p.replace(/\\/g, "/");
-}
-function getLatestTemplateTag(type, repoPath) {
-  try {
-    const tags = execFileSync(
-      "git",
-      ["tag", "-l", `template/${type}/*`, "--sort=-v:refname"],
-      { cwd: repoPath, encoding: "utf-8" }
-    ).trim();
-    if (!tags) return null;
-    return tags.split("\n")[0] ?? null;
-  } catch {
-    return null;
-  }
-}
-function getTemplateVersionFromTag(tag) {
-  const parts = tag.split("/");
-  return parts[parts.length - 1] ?? "";
-}
-function getTemplateDiff(repoPath, templatePath, fromTag, toTag) {
-  return execFileSync(
-    "git",
-    ["diff", `${fromTag}..${toTag}`, "--", toGitPath(templatePath)],
-    {
-      cwd: repoPath,
-      encoding: "utf-8"
-    }
-  );
-}
-function getFileAtTag(repoPath, tag, filePath) {
-  try {
-    return execFileSync("git", ["show", `${tag}:${toGitPath(filePath)}`], {
-      cwd: repoPath,
-      encoding: "utf-8"
-    });
-  } catch {
-    return null;
-  }
-}
-
-export {
-  getLatestTemplateTag,
-  getTemplateVersionFromTag,
-  getTemplateDiff,
-  getFileAtTag
-};

package/dist/chunk-V5EJIUBJ.js

@@ -1,60 +0,0 @@
-// src/utils/manifest.ts
-import path from "path";
-import fs from "fs-extra";
-var MANIFEST_FILENAME = ".mosaic-template.json";
-function getManifestPath(dir) {
-  return path.join(dir, MANIFEST_FILENAME);
-}
-async function readManifest(dir) {
-  const manifestPath = getManifestPath(dir);
-  if (!await fs.pathExists(manifestPath)) {
-    throw new Error(
-      `No ${MANIFEST_FILENAME} found in ${dir}. Run 'create init' to create one.`
-    );
-  }
-  const content = await fs.readFile(manifestPath, "utf-8");
-  try {
-    return JSON.parse(content);
-  } catch (error) {
-    throw new Error(
-      `Invalid JSON in ${MANIFEST_FILENAME}: ${error.message}`
-    );
-  }
-}
-async function writeManifest(dir, manifest) {
-  const manifestPath = getManifestPath(dir);
-  await fs.writeFile(manifestPath, JSON.stringify(manifest, null, 2) + "\n");
-}
-async function manifestExists(dir) {
-  return fs.pathExists(getManifestPath(dir));
-}
-function derivePlaceholders(appName, appTitle, repoName = appName) {
-  const nameSnake = appName.replace(/-/g, "_");
-  const repoNameSnake = repoName.replace(/-/g, "_");
-  return {
-    __APP_NAME__: appName,
-    __APP_TITLE__: appTitle,
-    __DB_NAME__: nameSnake + "_db",
-    __APP_NAME_UPPER__: appName.toUpperCase(),
-    __APP_NAME_SNAKE__: nameSnake,
-    __REPO_NAME__: repoName,
-    __REPO_NAME_SNAKE__: repoNameSnake
-  };
-}
-function resolveMosaicTemplatePath(options) {
-  if (options.mosaicTemplatePath)
-    return path.resolve(options.mosaicTemplatePath);
-  if (process.env.MOSAIC_TEMPLATE_PATH)
-    return path.resolve(process.env.MOSAIC_TEMPLATE_PATH);
-  throw new Error(
-    "Mosaic repo path required. Use --mosaic-template-path or set MOSAIC_TEMPLATE_PATH."
-  );
-}
-
-export {
-  readManifest,
-  writeManifest,
-  manifestExists,
-  derivePlaceholders,
-  resolveMosaicTemplatePath
-};

package/dist/index.d.ts

@@ -1 +0,0 @@
-#!/usr/bin/env node

package/dist/init-EQZ2TCSJ.js

@@ -1,96 +0,0 @@
-import {
-  VALID_PROJECT_TYPES,
-  isValidProjectType
-} from "./chunk-CO3YWUD6.js";
-import {
-  derivePlaceholders,
-  manifestExists,
-  writeManifest
-} from "./chunk-V5EJIUBJ.js";
-
-// src/commands/init.ts
-import path from "path";
-import fs from "fs-extra";
-import chalk from "chalk";
-import inquirer from "inquirer";
-async function initCommand(options) {
-  const cwd = process.cwd();
-  if (await manifestExists(cwd)) {
-    console.error(
-      chalk.red(".mosaic-template.json already exists in this directory.")
-    );
-    process.exit(1);
-  }
-  const pkgPath = path.join(cwd, "package.json");
-  let appName = path.basename(cwd);
-  if (await fs.pathExists(pkgPath)) {
-    const pkg = JSON.parse(await fs.readFile(pkgPath, "utf-8"));
-    appName = pkg.name?.replace(/^@[^/]+\//, "") || appName;
-  }
-  let templateType = options.type;
-  if (templateType && !isValidProjectType(templateType)) {
-    console.error(
-      chalk.red(
-        `Invalid template type "${templateType}". Valid types: ${VALID_PROJECT_TYPES.join(", ")}`
-      )
-    );
-    process.exit(1);
-  }
-  if (!templateType) {
-    const answer = await inquirer.prompt([
-      {
-        type: "list",
-        name: "type",
-        message: "Template type:",
-        choices: ["webapp", "library"]
-      }
-    ]);
-    templateType = answer.type;
-  }
-  const templateVersion = options.templateVersion || "1.0.0";
-  const appTitle = appName.split("-").map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
-  const manifest = {
-    templateType,
-    templateVersion,
-    templateCommit: "unknown",
-    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-    placeholders: derivePlaceholders(appName, appTitle),
-    source: {
-      templatePath: `packages/create-mosaic-module/templates/${templateType}`
-    }
-  };
-  await writeManifest(cwd, manifest);
-  const notesPath = path.join(cwd, "mosaic-template-notes.md");
-  if (!await fs.pathExists(notesPath)) {
-    await fs.writeFile(
-      notesPath,
-      `# Mosaic Divergence Notes
-
-Document intentional differences from the ${templateType} template here.
-Claude reads this file during sync to preserve your customizations.
-
-## Intentional Divergences
-
-`
-    );
-  }
-  console.log();
-  console.log(
-    chalk.green("\u2714"),
-    chalk.bold("Initialized .mosaic-template.json")
-  );
-  console.log();
-  console.log(chalk.dim("  Template:"), templateType);
-  console.log(chalk.dim("  Version:"), templateVersion);
-  console.log(chalk.dim("  App name:"), appName);
-  console.log();
-  console.log(
-    chalk.dim(
-      "Review .mosaic-template.json and mosaic-template-notes.md, then commit them."
-    )
-  );
-  console.log();
-}
-export {
-  initCommand
-};

package/dist/status-QW5TQDYY.js

@@ -1,76 +0,0 @@
-import {
-  getLatestTemplateTag,
-  getTemplateVersionFromTag
-} from "./chunk-DCM7JOSC.js";
-import {
-  readManifest
-} from "./chunk-V5EJIUBJ.js";
-
-// src/commands/status.ts
-import path from "path";
-import chalk from "chalk";
-async function statusCommand(options) {
-  const cwd = process.cwd();
-  try {
-    const manifest = await readManifest(cwd);
-    console.log();
-    console.log(chalk.bold("Mosaic Template Status"));
-    console.log();
-    console.log(chalk.dim("  Template type:"), manifest.templateType);
-    console.log(chalk.dim("  Current version:"), manifest.templateVersion);
-    console.log(chalk.dim("  Template commit:"), manifest.templateCommit);
-    console.log(chalk.dim("  Created:"), manifest.createdAt);
-    if (manifest.lastSyncedAt) {
-      console.log(chalk.dim("  Last synced:"), manifest.lastSyncedAt);
-    }
-    const rawPath = options.mosaicTemplatePath || process.env.MOSAIC_TEMPLATE_PATH;
-    const mosaicTemplatePath = rawPath ? path.resolve(rawPath) : void 0;
-    if (mosaicTemplatePath) {
-      const latestTag = getLatestTemplateTag(
-        manifest.templateType,
-        mosaicTemplatePath
-      );
-      if (latestTag) {
-        const latestVersion = getTemplateVersionFromTag(latestTag);
-        console.log(chalk.dim("  Latest version:"), latestVersion);
-        console.log();
-        if (latestVersion !== manifest.templateVersion) {
-          console.log(
-            chalk.yellow(
-              `  Update available: ${manifest.templateVersion} \u2192 ${latestVersion}`
-            )
-          );
-          console.log(
-            chalk.dim("  Run:"),
-            `create sync --mosaic-template-path ${mosaicTemplatePath}`
-          );
-        } else {
-          console.log(chalk.green("  Up to date"));
-        }
-      } else {
-        console.log();
-        console.log(
-          chalk.yellow("  No template tags found in mosaic repo.")
-        );
-        console.log(
-          chalk.dim("  Run:"),
-          `cd ${mosaicTemplatePath} && pnpm template:tag`
-        );
-      }
-    } else {
-      console.log();
-      console.log(
-        chalk.dim(
-          "  Use --mosaic-template-path or set MOSAIC_TEMPLATE_PATH to check for updates"
-        )
-      );
-    }
-    console.log();
-  } catch (error) {
-    console.error(chalk.red(error.message));
-    process.exit(1);
-  }
-}
-export {
-  statusCommand
-};