Developer MessagesClaude MessagesShow Tool Use

jeff

I've pushed and merged the PR for creating cwc-schema and created a new branch for the cwc-utils work. Let's do it!

Claude

Excellent! Let me create a comprehensive plan for implementing the cwc-utils package with profanity checking functionality.

Exited plan mode

Plan approved

Perfect! I've successfully created the cwc-utils package with profanity checking functionality. Here's what was implemented:

Summary of Changes

1. New Package: cwc-utils

Created packages/cwc-utils/ with cross-platform compatible utilities
Zero runtime dependencies (aligns with roll-your-own philosophy)
Works in both browser (React) and Node.js environments

2. Profanity Checking Implementation

Word List (src/profanity/word-list.ts):

Sourced from LDNOOBW (List of Dirty, Naughty, Obscene, and Otherwise Bad Words)
400+ English profanity words
Stored as a Set for O(1) lookup performance
Public domain license - safe for commercial use

Utilities (src/profanity/profanityChecker.ts):

containsProfanity(text, options?) - Check if text contains profanity
getProfaneWords(text, options?) - Get list of profane words found
validateNoProfanity(text, options?) - Validation result object
Optional leetspeak detection (converts b@dw0rd → badword etc.)

Usage Examples:

import { containsProfanity, validateNoProfanity } from 'cwc-utils';

// Username validation
if (containsProfanity(username)) {
  return { error: 'Username contains inappropriate content' };
}

// Project ID validation
const result = validateNoProfanity(projectId, {
  errorMessage: 'Project ID contains inappropriate content'
});

3. Documentation

Package CLAUDE.md (packages/cwc-utils/CLAUDE.md):

Complete API reference with examples
Usage patterns for cwc-api (backend) and cwc-website (frontend)
Cross-platform compatibility guidelines
Guidelines for adding new utilities

Root CLAUDE.md updates:

Added cwc-utils to Architecture/Monorepo Structure section
Added to Package-Specific Documentation section
Added cwc-schema to Package-Specific Documentation section (was missing)

4. Cleaned Up cwc-schema

Removed usernameWithProfanityCheck example from zodValidators.ts
Removed profanity reference from CLAUDE.md "When to Use Zod" section
Kept profanity checking as application-level logic, not schema-level validation

5. Verified Build

All packages typecheck successfully ✅
cwc-utils builds successfully ✅
cwc-schema still builds after cleanup ✅
Dist output created with all compiled files ✅

Key Design Decisions

✅ Application-Level Logic - Profanity checking is business logic, not schema validation. Applications decide when/how to check.

✅ Cross-Platform - Works in browser (React) and Node.js, no platform-specific APIs.

✅ Zero Dependencies - Pure TypeScript implementation, 100% control over the word list.

✅ Bundle Size - ~20KB including full word list, tree-shakeable exports.

✅ Performance - O(1) Set-based lookup, suitable for real-time validation.

✅ Customizable - Word list can be extended or modified in word-list.ts.

Next Steps

You can now use profanity checking in:

cwc-api: Validate usernames and projectIds during signup/creation
cwc-website: Real-time frontend validation in forms
cwc-auth: User registration validation

The package is ready to use and all code has been verified!

Session 08: cwc utils

35 files modified

CLAUDE.md

3 versions

Version 1

CLAUDE.md

This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.

Package-Specific Documentation

Claude Code automatically loads all CLAUDE.md files recursively. When working in a specific package or on package-specific tasks, refer to these package documentation files for detailed guidance:

cwc-types → packages/cwc-types/CLAUDE.md
- Type generation from database schema
- Entity type patterns (Strict Base + Partial)
- Union type naming conventions
- Request-scoped caching patterns
cwc-database → packages/cwc-database/CLAUDE.md
- Database schema conventions
- Table/index/view naming patterns
- Migration script patterns
- Database design patterns (JWT tables, multi-step processes, etc.)
cwc-deployment → packages/cwc-deployment/CLAUDE.md
- Deployment system architecture
- SSH-based deployment workflows
- Docker container management
- Troubleshooting and error handling

Project Overview

What is codingwithclaude?

A multi-tenant developer publishing platform: a dynamic, real-time publishing platform that serves as both a public feed for developer content and a private dashboard for external developers (users of the app) to manage and publish their own technical blog posts, organized by "Projects."

Project name & aliases

In this document and prompts from the developer, all of these names or phrases are assumed to refer to the project:

coding-with-claude-application
codingwithclaude
coding-with-claude
CWC or cwc

Proactive Documentation Philosophy

CRITICAL: This file is a living knowledge base that must be continuously updated.

As Claude Code works with the developer, it is EXPECTED to proactively capture all learnings, patterns, critical instructions, and feedback in this CLAUDE.md file WITHOUT being reminded. This is a professional partnership where:

Every gap discovered during planning or analysis → Document the pattern to prevent future occurrences
Every critical instruction from the developer → Add to relevant sections immediately
Every "I forgot to do X" moment → Create a checklist or rule to prevent repetition
Every architectural pattern learned → Document it for consistency
Every planning session insight → Capture the learning before implementation begins

When to update CLAUDE.md:

DURING planning sessions - This is where most learning happens through analysis, feedback, and corrections
After receiving critical feedback - Document the expectation immediately
After discovering a bug or oversight - Add checks/rules to prevent it
After analysis reveals gaps - Document what to check in the future
When the developer explains "this is how we do X" - Add it to the guide
After implementing a new feature - Capture any additional patterns discovered during execution

Planning sessions are especially critical: The analysis, feedback, and corrections that happen during planning contain the most valuable learnings. Update CLAUDE.md with these insights BEFORE starting implementation, not after.

Professional expectation: The developer should not need to repeatedly point out the same oversights or remind Claude Code to document learnings. Like professional teammates, we learn from each interaction and build institutional knowledge.

Format: When updating this file, maintain clear structure, provide code examples where helpful, and organize related concepts together. Focus exclusively on information that helps Claude Code operate effectively during AI-assisted coding sessions.

Package-Specific Documentation: When learning package-specific patterns, update the appropriate package CLAUDE.md file, not this root file.

Documentation Organization in Monorepos

Critical learnings about Claude Code documentation structure:

Claude Code automatically loads all CLAUDE.md files recursively:
- Reads CLAUDE.md in current working directory
- Recurses upward to parent directories (stops at workspace root)
- Discovers nested CLAUDE.md files in subdirectories
- All files are loaded together - they complement, not replace each other
Package-specific CLAUDE.md is the standard pattern for monorepos:
- Root CLAUDE.md contains monorepo-wide conventions (tooling, git workflow, shared patterns)
- Package CLAUDE.md contains package-specific patterns (database schema, deployment, type generation)
- Working from any directory loads both root and relevant package docs automatically
Performance limit: 40,000 characters per file:
- Claude Code shows performance warning when CLAUDE.md exceeds 40k characters
- Solution: Split into package-specific files, not multiple files in .claude/ directory
- Only CLAUDE.md files are automatically loaded; other .md files in .claude/ are NOT
Optimize for AI-assisted coding, not human readers:
- Include patterns, conventions, code examples, and strict rules
- Include "what to check during planning" and "lessons learned" sections
- Exclude content primarily for human developers (marketing copy, general explanations)
- Focus on actionable information needed during coding sessions

When to create package CLAUDE.md:

Package has unique architectural patterns
Package has specific conventions (schema rules, deployment procedures)
Package has domain-specific knowledge (auth flows, type generation)
Package documentation would exceed ~500 lines in root file

File Access Restrictions and Security Boundaries

Claude Code operates under strict file access restrictions to protect sensitive data:

Workspace Boundaries

Claude Code can ONLY access files within the monorepo root: ./coding-with-claude-application
No access to parent directories, system files, or files outside this workspace
This is enforced by Claude Code's security model

Prohibited File Access

Claude Code is explicitly blocked from reading or writing:

Environment files:
- .env files at any location
- .env.* files (e.g., .env.local, .env.production, .env.dev)
- *.env files (e.g., prod.cwc-sql.env, dev.cwc-storage.env, test.cwc-app.env)
- Any variation of environment configuration files
Secret and credential files:
- Any directory named secrets/, secret/, or private/
- Any directory with secret, secrets, or private in its path
- Any file with secret, secrets, private, or credentials in its filename
- Service account JSON files (service-account-*.json)
- Firebase configuration files (google-services.json, GoogleService-Info.plist)
- Any file matching *credentials*.json
Rationale:
- Prevents accidental exposure of API keys, database passwords, and authentication tokens
- Protects production credentials and service account keys
- Reduces risk of sensitive data being included in code examples or logs
- Enforces principle of least privilege

These restrictions are enforced in .claude/settings.json and cannot be overridden during a session.

Git Workflow

The developer handles all git operations manually. Claude should:

Never initiate git commits, pushes, pulls, or any write operations
Only use git for read-only informational purposes (status, diff, log, show)
Not proactively suggest git operations unless explicitly asked

Git write operations are blocked in .claude/settings.json to enforce this workflow.

Architecture Overview

Monorepo Structure (future plan)

root project: /coding-with-claude-application
packages (apps, microservices, utilities):
- cwc-types: shared TypeScript types to be used in all other packages
- cwc-deployment: custom deployment CLI for SSH-based deployment to remote servers
- cwc-backend-utils: shared Node.js utilities that backend/api packages will consume
- cwc-website: public frontend end web application
- cwc-auth: authentication microservice, providing login, logout, signup, password reset, etc.
- cwc-api: the main data api used by cwc-website to read & write data, enforce auth, role-based access policies, and business rules/logic
- cwc-dashboard: an administrative web dashboard app for site owners to manage the app & data
- cwc-admin-api: the admin and data api used by the cwc-dashboard app
- cwc-database: database scripts to create tables, indexes, views, as well as insert configuration data
- cwc-schema: shared schema management library that may be used by frontend and backend packages
- cwc-sql: the only backend service that interacts directly with the database server, uses schema to dynamically generate sql statements
- cwc-e2e: a set of end-to-end tests

Tech Stack: to be determined as we build each package, update this documentation as we go.

Development Tooling & Infrastructure

Monorepo Management

pnpm v9.x + Turborepo v2.x

pnpm workspaces for package management and dependency resolution
- Configured in pnpm-workspace.yaml
- Packages located in packages/*
- Uses content-addressable storage for disk efficiency
- Strict dependency resolution prevents phantom dependencies
Turborepo for task orchestration and caching
- Configured in turbo.json
- Intelligent parallel execution based on dependency graph
- Local caching for faster rebuilds
- Pipeline tasks: build, dev, test, lint, typecheck

Node.js Version

Node.js 22 LTS (specified in .nvmrc)
Required for all development and production environments
Use nvm for version management

Code Quality Tools

TypeScript v5.4+

Configured in tsconfig.base.json
Strict mode enabled with enhanced type checking
JavaScript explicitly disallowed (allowJs: false)
Monorepo-optimized with composite projects
Individual packages extend base config

ESLint v8.x with TypeScript

Configured in .eslintrc.json
Uses @typescript-eslint/strict ruleset
Enforces explicit function return types
Prohibits any type and non-null assertions
Strict boolean expressions required

Prettier v3.x

Configured in .prettierrc.json
Standards:
- Single quotes
- 2-space indentation
- 100 character line width
- Trailing commas (ES5)
- LF line endings

Root Scripts

Run from monorepo root using pnpm:

pnpm build - Build all packages (parallel, cached)
pnpm dev - Run all packages in dev mode
pnpm test - Run tests across all packages (parallel, cached)
pnpm lint - Lint all packages (parallel, cached)
pnpm typecheck - Type-check all packages (parallel, cached)
pnpm format - Format all files with Prettier
pnpm format:check - Check formatting without changes

Development Workflow

Before starting work:
- Ensure Node 22 is active: nvm use
- Install dependencies: pnpm install
During development:
- Run dev mode: pnpm dev (in specific package or root)
- Format code: pnpm format
Before committing:
- Type-check: pnpm typecheck
- Lint: pnpm lint
- Format check: pnpm format:check
- Run tests: pnpm test

Package Creation Conventions

When creating a new package in the monorepo:

Version Number: Always start new packages at version 1.0.0 (not 0.0.1)
- Example: "version": "1.0.0" in package.json
- This is a project preference for consistency
Package Structure:
- Follow existing package patterns (see cwc-types as reference)
- Include package.json, tsconfig.json extending base config
- Place source files in src/ directory
- Include appropriate build and typecheck scripts
Package Naming:
- Use cwc- prefix for all CWC packages
- Use kebab-case: cwc-types, cwc-backend-utils, etc.
Package Documentation:
- Create packages/{package-name}/CLAUDE.md for package-specific patterns and conventions
- Document architecture decisions, design patterns, and critical implementation details
- Keep package docs focused on information needed for AI-assisted coding

Key Architectural Decisions & Patterns

MariaDB Database

Strong Schema Enforcement
Transaction support
Efficient Joins
Data normalization
Sophisticated Querying and Analytics

Details: See packages/cwc-database/CLAUDE.md for complete database schema conventions.

TypeScript

Strict mode enabled (strict: true)
Shared types in cwc-types package; duplicating types in separate projects leads to inconsistencies, incompatibility, confusion, and extra work
Never use any - prefer unknown if type is truly unknown
Use string literal union types, not enums
Use type for entity definitions, not interface
Run typecheck before committing

Details: See packages/cwc-types/CLAUDE.md for complete TypeScript patterns and type generation.

Cloud-Agnostic Microservices

CWC uses a microservices architecture deployed as Docker containers potentially deployed across multiple datacenters.

Vendor lock-in is a real business risk. Cloud providers can change pricing, deny service access, or deprecate features at any time.
Cloud-agnostic microservices architecture allows switching hosting providers with minimal effort.
Preparation for Scale - can scale by adding infrastructure (more containers, load balancers) rather than rewriting code and specific services can be scaled based on actual load patterns

Environment Configuration

Each package will read configuration values from a .env file, provided at runtime, tailored to the runtime environment

Development Process

Tool, Framework, Version selection

mainstream, widely accepted, and thoroughly tested & proven tools only
the desire is to use the latest stable versions of the various tools

Adopt a "roll-your-own" mentality

we want to minimize the number of unnecessary dependencies to avoid headaches when upgrading our core tech stack
when it makes sense, we will build our own components and utilities rather than relying on a 3rd party package

Version 2

CLAUDE.md

This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.

Package-Specific Documentation

Claude Code automatically loads all CLAUDE.md files recursively. When working in a specific package or on package-specific tasks, refer to these package documentation files for detailed guidance:

cwc-types → packages/cwc-types/CLAUDE.md
- Type generation from database schema
- Entity type patterns (Strict Base + Partial)
- Union type naming conventions
- Request-scoped caching patterns
cwc-database → packages/cwc-database/CLAUDE.md
- Database schema conventions
- Table/index/view naming patterns
- Migration script patterns
- Database design patterns (JWT tables, multi-step processes, etc.)
cwc-deployment → packages/cwc-deployment/CLAUDE.md
- Deployment system architecture
- SSH-based deployment workflows
- Docker container management
- Troubleshooting and error handling

Project Overview

What is codingwithclaude?

Project name & aliases

In this document and prompts from the developer, all of these names or phrases are assumed to refer to the project:

coding-with-claude-application
codingwithclaude
coding-with-claude
CWC or cwc

Proactive Documentation Philosophy

CRITICAL: This file is a living knowledge base that must be continuously updated.

Every gap discovered during planning or analysis → Document the pattern to prevent future occurrences
Every critical instruction from the developer → Add to relevant sections immediately
Every "I forgot to do X" moment → Create a checklist or rule to prevent repetition
Every architectural pattern learned → Document it for consistency
Every planning session insight → Capture the learning before implementation begins

When to update CLAUDE.md:

DURING planning sessions - This is where most learning happens through analysis, feedback, and corrections
After receiving critical feedback - Document the expectation immediately
After discovering a bug or oversight - Add checks/rules to prevent it
After analysis reveals gaps - Document what to check in the future
When the developer explains "this is how we do X" - Add it to the guide
After implementing a new feature - Capture any additional patterns discovered during execution

Package-Specific Documentation: When learning package-specific patterns, update the appropriate package CLAUDE.md file, not this root file.

Documentation Organization in Monorepos

Critical learnings about Claude Code documentation structure:

Claude Code automatically loads all CLAUDE.md files recursively:
- Reads CLAUDE.md in current working directory
- Recurses upward to parent directories (stops at workspace root)
- Discovers nested CLAUDE.md files in subdirectories
- All files are loaded together - they complement, not replace each other
Package-specific CLAUDE.md is the standard pattern for monorepos:
- Root CLAUDE.md contains monorepo-wide conventions (tooling, git workflow, shared patterns)
- Package CLAUDE.md contains package-specific patterns (database schema, deployment, type generation)
- Working from any directory loads both root and relevant package docs automatically
Performance limit: 40,000 characters per file:
- Claude Code shows performance warning when CLAUDE.md exceeds 40k characters
- Solution: Split into package-specific files, not multiple files in .claude/ directory
- Only CLAUDE.md files are automatically loaded; other .md files in .claude/ are NOT
Optimize for AI-assisted coding, not human readers:
- Include patterns, conventions, code examples, and strict rules
- Include "what to check during planning" and "lessons learned" sections
- Exclude content primarily for human developers (marketing copy, general explanations)
- Focus on actionable information needed during coding sessions

When to create package CLAUDE.md:

Package has unique architectural patterns
Package has specific conventions (schema rules, deployment procedures)
Package has domain-specific knowledge (auth flows, type generation)
Package documentation would exceed ~500 lines in root file

File Access Restrictions and Security Boundaries

Claude Code operates under strict file access restrictions to protect sensitive data:

Workspace Boundaries

Claude Code can ONLY access files within the monorepo root: ./coding-with-claude-application
No access to parent directories, system files, or files outside this workspace
This is enforced by Claude Code's security model

Prohibited File Access

Claude Code is explicitly blocked from reading or writing:

Environment files:
- .env files at any location
- .env.* files (e.g., .env.local, .env.production, .env.dev)
- *.env files (e.g., prod.cwc-sql.env, dev.cwc-storage.env, test.cwc-app.env)
- Any variation of environment configuration files
Secret and credential files:
- Any directory named secrets/, secret/, or private/
- Any directory with secret, secrets, or private in its path
- Any file with secret, secrets, private, or credentials in its filename
- Service account JSON files (service-account-*.json)
- Firebase configuration files (google-services.json, GoogleService-Info.plist)
- Any file matching *credentials*.json
Rationale:
- Prevents accidental exposure of API keys, database passwords, and authentication tokens
- Protects production credentials and service account keys
- Reduces risk of sensitive data being included in code examples or logs
- Enforces principle of least privilege

These restrictions are enforced in .claude/settings.json and cannot be overridden during a session.

Git Workflow

The developer handles all git operations manually. Claude should:

Never initiate git commits, pushes, pulls, or any write operations
Only use git for read-only informational purposes (status, diff, log, show)
Not proactively suggest git operations unless explicitly asked

Git write operations are blocked in .claude/settings.json to enforce this workflow.

Architecture Overview

Monorepo Structure (future plan)

root project: /coding-with-claude-application
packages (apps, microservices, utilities):
- cwc-types: shared TypeScript types to be used in all other packages
- cwc-deployment: custom deployment CLI for SSH-based deployment to remote servers
- cwc-backend-utils: shared Node.js utilities that backend/api packages will consume
- cwc-website: public frontend end web application
- cwc-auth: authentication microservice, providing login, logout, signup, password reset, etc.
- cwc-api: the main data api used by cwc-website to read & write data, enforce auth, role-based access policies, and business rules/logic
- cwc-dashboard: an administrative web dashboard app for site owners to manage the app & data
- cwc-admin-api: the admin and data api used by the cwc-dashboard app
- cwc-database: database scripts to create tables, indexes, views, as well as insert configuration data
- cwc-schema: shared schema management library that may be used by frontend and backend packages
- cwc-sql: the only backend service that interacts directly with the database server, uses schema to dynamically generate sql statements
- cwc-e2e: a set of end-to-end tests

Tech Stack: to be determined as we build each package, update this documentation as we go.

Development Tooling & Infrastructure

Monorepo Management

pnpm v9.x + Turborepo v2.x

pnpm workspaces for package management and dependency resolution
- Configured in pnpm-workspace.yaml
- Packages located in packages/*
- Uses content-addressable storage for disk efficiency
- Strict dependency resolution prevents phantom dependencies
Turborepo for task orchestration and caching
- Configured in turbo.json
- Intelligent parallel execution based on dependency graph
- Local caching for faster rebuilds
- Pipeline tasks: build, dev, test, lint, typecheck

Node.js Version

Node.js 22 LTS (specified in .nvmrc)
Required for all development and production environments
Use nvm for version management

Code Quality Tools

TypeScript v5.4+

Configured in tsconfig.base.json
Strict mode enabled with enhanced type checking
JavaScript explicitly disallowed (allowJs: false)
Monorepo-optimized with composite projects
Individual packages extend base config

Module Resolution: bundler

Uses "moduleResolution": "bundler" in tsconfig.base.json
Uses "module": "ES2022" (required for bundler resolution)
Allows clean TypeScript imports without .js extensions
- ✅ Correct: import { Schema } from './types'
- ❌ Not needed: import { Schema } from './types.js'
Still produces correct ES module output in compiled JavaScript
Designed for TypeScript projects compiled by tsc or bundlers

Why bundler over NodeNext:

Better DX: No .js extensions in TypeScript source files
Modern standard: Industry standard for TypeScript libraries and monorepos
Same output: Still generates proper ES modules (.js files)
No trade-offs: Type safety and module compatibility maintained

Note: Previously used "moduleResolution": "NodeNext" which required .js extensions per ES modules spec (e.g., import './types.js'). Switched to bundler in session 007 for cleaner imports across all packages.

ESLint v8.x with TypeScript

Configured in .eslintrc.json
Uses @typescript-eslint/strict ruleset
Enforces explicit function return types
Prohibits any type and non-null assertions
Strict boolean expressions required

Prettier v3.x

Configured in .prettierrc.json
Standards:
- Single quotes
- 2-space indentation
- 100 character line width
- Trailing commas (ES5)
- LF line endings

Root Scripts

Run from monorepo root using pnpm:

pnpm build - Build all packages (parallel, cached)
pnpm dev - Run all packages in dev mode
pnpm test - Run tests across all packages (parallel, cached)
pnpm lint - Lint all packages (parallel, cached)
pnpm typecheck - Type-check all packages (parallel, cached)
pnpm format - Format all files with Prettier
pnpm format:check - Check formatting without changes

Development Workflow

Before starting work:
- Ensure Node 22 is active: nvm use
- Install dependencies: pnpm install
During development:
- Run dev mode: pnpm dev (in specific package or root)
- Format code: pnpm format
Before committing:
- Type-check: pnpm typecheck
- Lint: pnpm lint
- Format check: pnpm format:check
- Run tests: pnpm test

Package Creation Conventions

When creating a new package in the monorepo:

Version Number: Always start new packages at version 1.0.0 (not 0.0.1)
- Example: "version": "1.0.0" in package.json
- This is a project preference for consistency
Package Structure:
- Follow existing package patterns (see cwc-types as reference)
- Include package.json, tsconfig.json extending base config
- Place source files in src/ directory
- Include appropriate build and typecheck scripts
Package Naming:
- Use cwc- prefix for all CWC packages
- Use kebab-case: cwc-types, cwc-backend-utils, etc.
Package Documentation:
- Create packages/{package-name}/CLAUDE.md for package-specific patterns and conventions
- Document architecture decisions, design patterns, and critical implementation details
- Keep package docs focused on information needed for AI-assisted coding

Key Architectural Decisions & Patterns

MariaDB Database

Strong Schema Enforcement
Transaction support
Efficient Joins
Data normalization
Sophisticated Querying and Analytics

Details: See packages/cwc-database/CLAUDE.md for complete database schema conventions.

TypeScript

Strict mode enabled (strict: true)
Shared types in cwc-types package; duplicating types in separate projects leads to inconsistencies, incompatibility, confusion, and extra work
Never use any - prefer unknown if type is truly unknown
Use string literal union types, not enums
Use type for entity definitions, not interface
Run typecheck before committing

Details: See packages/cwc-types/CLAUDE.md for complete TypeScript patterns and type generation.

Cloud-Agnostic Microservices

CWC uses a microservices architecture deployed as Docker containers potentially deployed across multiple datacenters.

Vendor lock-in is a real business risk. Cloud providers can change pricing, deny service access, or deprecate features at any time.
Cloud-agnostic microservices architecture allows switching hosting providers with minimal effort.
Preparation for Scale - can scale by adding infrastructure (more containers, load balancers) rather than rewriting code and specific services can be scaled based on actual load patterns

Environment Configuration

Each package will read configuration values from a .env file, provided at runtime, tailored to the runtime environment

Development Process

Tool, Framework, Version selection

mainstream, widely accepted, and thoroughly tested & proven tools only
the desire is to use the latest stable versions of the various tools

Adopt a "roll-your-own" mentality

we want to minimize the number of unnecessary dependencies to avoid headaches when upgrading our core tech stack
when it makes sense, we will build our own components and utilities rather than relying on a 3rd party package

Version 3 (latest)

CLAUDE.md

This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.

Package-Specific Documentation

Claude Code automatically loads all CLAUDE.md files recursively. When working in a specific package or on package-specific tasks, refer to these package documentation files for detailed guidance:

cwc-types → packages/cwc-types/CLAUDE.md
- Type generation from database schema
- Entity type patterns (Strict Base + Partial)
- Union type naming conventions
- Request-scoped caching patterns
cwc-database → packages/cwc-database/CLAUDE.md
- Database schema conventions
- Table/index/view naming patterns
- Migration script patterns
- Database design patterns (JWT tables, multi-step processes, etc.)
cwc-deployment → packages/cwc-deployment/CLAUDE.md
- Deployment system architecture
- SSH-based deployment workflows
- Docker container management
- Troubleshooting and error handling
cwc-schema → packages/cwc-schema/CLAUDE.md
- Schema definition patterns
- Runtime validation functions
- Hybrid validation with Zod
- Column type definitions
cwc-utils → packages/cwc-utils/CLAUDE.md
- Shared utilities (browser + Node.js)
- Profanity checking and content filtering
- Cross-platform compatibility guidelines
- Adding new utilities

Project Overview

What is codingwithclaude?

Project name & aliases

In this document and prompts from the developer, all of these names or phrases are assumed to refer to the project:

coding-with-claude-application
codingwithclaude
coding-with-claude
CWC or cwc

Proactive Documentation Philosophy

CRITICAL: This file is a living knowledge base that must be continuously updated.

Every gap discovered during planning or analysis → Document the pattern to prevent future occurrences
Every critical instruction from the developer → Add to relevant sections immediately
Every "I forgot to do X" moment → Create a checklist or rule to prevent repetition
Every architectural pattern learned → Document it for consistency
Every planning session insight → Capture the learning before implementation begins

When to update CLAUDE.md:

DURING planning sessions - This is where most learning happens through analysis, feedback, and corrections
After receiving critical feedback - Document the expectation immediately
After discovering a bug or oversight - Add checks/rules to prevent it
After analysis reveals gaps - Document what to check in the future
When the developer explains "this is how we do X" - Add it to the guide
After implementing a new feature - Capture any additional patterns discovered during execution

Package-Specific Documentation: When learning package-specific patterns, update the appropriate package CLAUDE.md file, not this root file.

Documentation Organization in Monorepos

Critical learnings about Claude Code documentation structure:

Claude Code automatically loads all CLAUDE.md files recursively:
- Reads CLAUDE.md in current working directory
- Recurses upward to parent directories (stops at workspace root)
- Discovers nested CLAUDE.md files in subdirectories
- All files are loaded together - they complement, not replace each other
Package-specific CLAUDE.md is the standard pattern for monorepos:
- Root CLAUDE.md contains monorepo-wide conventions (tooling, git workflow, shared patterns)
- Package CLAUDE.md contains package-specific patterns (database schema, deployment, type generation)
- Working from any directory loads both root and relevant package docs automatically
Performance limit: 40,000 characters per file:
- Claude Code shows performance warning when CLAUDE.md exceeds 40k characters
- Solution: Split into package-specific files, not multiple files in .claude/ directory
- Only CLAUDE.md files are automatically loaded; other .md files in .claude/ are NOT
Optimize for AI-assisted coding, not human readers:
- Include patterns, conventions, code examples, and strict rules
- Include "what to check during planning" and "lessons learned" sections
- Exclude content primarily for human developers (marketing copy, general explanations)
- Focus on actionable information needed during coding sessions

When to create package CLAUDE.md:

Package has unique architectural patterns
Package has specific conventions (schema rules, deployment procedures)
Package has domain-specific knowledge (auth flows, type generation)
Package documentation would exceed ~500 lines in root file

File Access Restrictions and Security Boundaries

Claude Code operates under strict file access restrictions to protect sensitive data:

Workspace Boundaries

Claude Code can ONLY access files within the monorepo root: ./coding-with-claude-application
No access to parent directories, system files, or files outside this workspace
This is enforced by Claude Code's security model

Prohibited File Access

Claude Code is explicitly blocked from reading or writing:

Environment files:
- .env files at any location
- .env.* files (e.g., .env.local, .env.production, .env.dev)
- *.env files (e.g., prod.cwc-sql.env, dev.cwc-storage.env, test.cwc-app.env)
- Any variation of environment configuration files
Secret and credential files:
- Any directory named secrets/, secret/, or private/
- Any directory with secret, secrets, or private in its path
- Any file with secret, secrets, private, or credentials in its filename
- Service account JSON files (service-account-*.json)
- Firebase configuration files (google-services.json, GoogleService-Info.plist)
- Any file matching *credentials*.json
Rationale:
- Prevents accidental exposure of API keys, database passwords, and authentication tokens
- Protects production credentials and service account keys
- Reduces risk of sensitive data being included in code examples or logs
- Enforces principle of least privilege

These restrictions are enforced in .claude/settings.json and cannot be overridden during a session.

Git Workflow

The developer handles all git operations manually. Claude should:

Never initiate git commits, pushes, pulls, or any write operations
Only use git for read-only informational purposes (status, diff, log, show)
Not proactively suggest git operations unless explicitly asked

Git write operations are blocked in .claude/settings.json to enforce this workflow.

Architecture Overview

Monorepo Structure (future plan)

root project: /coding-with-claude-application
packages (apps, microservices, utilities):
- cwc-types: shared TypeScript types to be used in all other packages
- cwc-utils: shared utilities for browser and Node.js (profanity checking, validation helpers, etc.)
- cwc-deployment: custom deployment CLI for SSH-based deployment to remote servers
- cwc-backend-utils: shared Node.js utilities that backend/api packages will consume
- cwc-website: public frontend end web application
- cwc-auth: authentication microservice, providing login, logout, signup, password reset, etc.
- cwc-api: the main data api used by cwc-website to read & write data, enforce auth, role-based access policies, and business rules/logic
- cwc-dashboard: an administrative web dashboard app for site owners to manage the app & data
- cwc-admin-api: the admin and data api used by the cwc-dashboard app
- cwc-database: database scripts to create tables, indexes, views, as well as insert configuration data
- cwc-schema: shared schema management library that may be used by frontend and backend packages
- cwc-sql: the only backend service that interacts directly with the database server, uses schema to dynamically generate sql statements
- cwc-e2e: a set of end-to-end tests

Tech Stack: to be determined as we build each package, update this documentation as we go.

Development Tooling & Infrastructure

Monorepo Management

pnpm v9.x + Turborepo v2.x

pnpm workspaces for package management and dependency resolution
- Configured in pnpm-workspace.yaml
- Packages located in packages/*
- Uses content-addressable storage for disk efficiency
- Strict dependency resolution prevents phantom dependencies
Turborepo for task orchestration and caching
- Configured in turbo.json
- Intelligent parallel execution based on dependency graph
- Local caching for faster rebuilds
- Pipeline tasks: build, dev, test, lint, typecheck

Node.js Version

Node.js 22 LTS (specified in .nvmrc)
Required for all development and production environments
Use nvm for version management

Code Quality Tools

TypeScript v5.4+

Configured in tsconfig.base.json
Strict mode enabled with enhanced type checking
JavaScript explicitly disallowed (allowJs: false)
Monorepo-optimized with composite projects
Individual packages extend base config

Module Resolution: bundler

Uses "moduleResolution": "bundler" in tsconfig.base.json
Uses "module": "ES2022" (required for bundler resolution)
Allows clean TypeScript imports without .js extensions
- ✅ Correct: import { Schema } from './types'
- ❌ Not needed: import { Schema } from './types.js'
Still produces correct ES module output in compiled JavaScript
Designed for TypeScript projects compiled by tsc or bundlers

Why bundler over NodeNext:

Better DX: No .js extensions in TypeScript source files
Modern standard: Industry standard for TypeScript libraries and monorepos
Same output: Still generates proper ES modules (.js files)
No trade-offs: Type safety and module compatibility maintained

ESLint v8.x with TypeScript

Configured in .eslintrc.json
Uses @typescript-eslint/strict ruleset
Enforces explicit function return types
Prohibits any type and non-null assertions
Strict boolean expressions required

Prettier v3.x

Configured in .prettierrc.json
Standards:
- Single quotes
- 2-space indentation
- 100 character line width
- Trailing commas (ES5)
- LF line endings

Root Scripts

Run from monorepo root using pnpm:

pnpm build - Build all packages (parallel, cached)
pnpm dev - Run all packages in dev mode
pnpm test - Run tests across all packages (parallel, cached)
pnpm lint - Lint all packages (parallel, cached)
pnpm typecheck - Type-check all packages (parallel, cached)
pnpm format - Format all files with Prettier
pnpm format:check - Check formatting without changes

Development Workflow

Before starting work:
- Ensure Node 22 is active: nvm use
- Install dependencies: pnpm install
During development:
- Run dev mode: pnpm dev (in specific package or root)
- Format code: pnpm format
Before committing:
- Type-check: pnpm typecheck
- Lint: pnpm lint
- Format check: pnpm format:check
- Run tests: pnpm test

Package Creation Conventions

When creating a new package in the monorepo:

Version Number: Always start new packages at version 1.0.0 (not 0.0.1)
- Example: "version": "1.0.0" in package.json
- This is a project preference for consistency
Package Structure:
- Follow existing package patterns (see cwc-types as reference)
- Include package.json, tsconfig.json extending base config
- Place source files in src/ directory
- Include appropriate build and typecheck scripts
Package Naming:
- Use cwc- prefix for all CWC packages
- Use kebab-case: cwc-types, cwc-backend-utils, etc.
Package Documentation:
- Create packages/{package-name}/CLAUDE.md for package-specific patterns and conventions
- Document architecture decisions, design patterns, and critical implementation details
- Keep package docs focused on information needed for AI-assisted coding

Key Architectural Decisions & Patterns

MariaDB Database

Strong Schema Enforcement
Transaction support
Efficient Joins
Data normalization
Sophisticated Querying and Analytics

Details: See packages/cwc-database/CLAUDE.md for complete database schema conventions.

TypeScript

Strict mode enabled (strict: true)
Shared types in cwc-types package; duplicating types in separate projects leads to inconsistencies, incompatibility, confusion, and extra work
Never use any - prefer unknown if type is truly unknown
Use string literal union types, not enums
Use type for entity definitions, not interface
Run typecheck before committing

Details: See packages/cwc-types/CLAUDE.md for complete TypeScript patterns and type generation.

Cloud-Agnostic Microservices

CWC uses a microservices architecture deployed as Docker containers potentially deployed across multiple datacenters.

Vendor lock-in is a real business risk. Cloud providers can change pricing, deny service access, or deprecate features at any time.
Cloud-agnostic microservices architecture allows switching hosting providers with minimal effort.
Preparation for Scale - can scale by adding infrastructure (more containers, load balancers) rather than rewriting code and specific services can be scaled based on actual load patterns

Environment Configuration

Each package will read configuration values from a .env file, provided at runtime, tailored to the runtime environment

Development Process

Tool, Framework, Version selection

mainstream, widely accepted, and thoroughly tested & proven tools only
the desire is to use the latest stable versions of the various tools

Adopt a "roll-your-own" mentality

we want to minimize the number of unnecessary dependencies to avoid headaches when upgrading our core tech stack
when it makes sense, we will build our own components and utilities rather than relying on a 3rd party package

packages/cwc-schema/CLAUDE.md

4 versions

Version 1

cwc-schema Package

Database schema definitions with validation rules for the CWC application. Provides a single source of truth for database structure, validation logic, and schema metadata.

Package Purpose

Define database table and view schemas programmatically
Provide runtime validation for entity data
Centralize column definitions and validation rules
Enable schema-driven tooling (future: SQL generation, admin interfaces)
Document database structure in TypeScript

Package Structure

cwc-schema/
├── src/
│   ├── types.ts                  - Core schema type definitions
│   ├── columnTypes.ts            - Reusable column definitions (36 types)
│   ├── validation/
│   │   ├── regexPatterns.ts     - Validation regex constants
│   │   └── validator.ts         - Runtime validation functions
│   ├── tables/                  - Table schema definitions (18 files)
│   │   ├── abuseReport.ts
│   │   ├── adminUser.ts
│   │   ├── ... (alphabetically ordered)
│   │   └── userJwt.ts
│   └── index.ts                 - Schema aggregator and exports
└── dist/                        - Compiled output

Architecture

Relationship to Other Packages

cwc-schema vs cwc-types:

cwc-schema: Validation rules, column metadata, schema structure (this package)
cwc-types: TypeScript entity types for compile-time safety (manually maintained)
Separation: Schema provides runtime validation; types provide compile-time safety
No codegen: Schema does NOT generate cwc-types (both maintained separately for now)
Future: May revisit to have schema generate types as single source of truth

Source of Truth:

Database: SQL scripts in cwc-database remain authoritative for database structure
Schema mirrors SQL: cwc-schema mirrors the SQL definitions for TypeScript/validation purposes
Manual sync: When SQL changes, update both cwc-schema AND cwc-types manually
Future: May transition to schema-first with SQL generation

Core Types

SchemaColumn: Defines a single database column with validation rules

type SchemaColumn = {
  type: 'string' | 'number' | 'boolean' | 'object';
  name: string;                    // Column name in database
  typename: string;                // Semantic category (uuid, email, pkid)
  required?: boolean;              // Whether column is required

  // String validation
  minLength?: number;
  maxLength?: number;
  regex?: RegExp;
  values?: string[];               // Enum values

  // Number validation
  minValue?: number;
  maxValue?: number;

  // Foreign key metadata
  foreignKey?: {
    table: string;
    column: string;
    onDelete?: 'CASCADE' | 'SET NULL' | 'RESTRICT';
  };
};

Schema: Defines a complete table or view schema

type Schema = {
  name: string;                    // Table/view name
  type: 'table' | 'view';
  version?: string;                // Schema version (e.g., '1.0.0')
  pkid: string | undefined;        // Primary key column name (undefined for views)
  columns: Record<string, SchemaColumn>;
};

Schema Definition Patterns

Reusable Column Types (Spread Syntax)

Pattern: Define base column types in columnTypes.ts, customize via spread syntax

// columnTypes.ts - Base definition
export const pkid: SchemaColumn = {
  type: 'number',
  name: 'pkid',
  typename: 'pkid',
  minValue: 0,
};

export const uuid: SchemaColumn = {
  type: 'string',
  minLength: 36,
  maxLength: 36,
  regex: UUID_REGEX,
  name: 'uuid',
  typename: 'uuid',
};

// tables/user.ts - Customized usage
userPkId: { ...pkid, name: 'userPkId' },
deviceId: { ...uuid, name: 'deviceId' },

Benefits:

DRY: Validation rules defined once, reused everywhere
Consistency: All UUIDs use same regex, all PKIDs have minValue: 0
Easy updates: Change validation in one place, applies everywhere
Type safety: TypeScript ensures column definitions are valid

Foreign Key Relationships

Pattern: Infer foreign keys from column names ending in PkId (except table's own PkId)

userPkId: {
  ...pkid,
  name: 'userPkId',
  typename: 'foreignKey',
  foreignKey: { table: 'user', column: 'userPkId' },
},

projectPkId: {
  ...pkid,
  name: 'projectPkId',
  typename: 'foreignKey',
  foreignKey: { table: 'project', column: 'projectPkId' },
},

Note: Foreign keys are metadata only; CWC database does NOT use DB-level FK constraints (see cwc-database/CLAUDE.md)

Enum-Like VARCHAR Fields

Pattern: Use values array to define allowed enum values

status: {
  type: 'string',
  typename: 'string',
  minLength: 4,
  maxLength: 25,
  values: ['submitted', 'investigation', 'dismissed', 'resolved', 'retracted'],
  name: 'status',
},

loginType: {
  type: 'string',
  typename: 'string',
  minLength: 3,
  maxLength: 25,
  values: ['cwc', 'facebook', 'google'],
  name: 'loginType',
},

Important: These values must match the potential-values comments in SQL and the union types in cwc-types

Required vs Optional Fields

Pattern: Mark fields as required: true only when they are NOT NULL in SQL AND cannot be null in business logic

// Required field (NOT NULL in SQL)
entityPkId: {
  ...pkid,
  name: 'entityPkId',
  typename: 'foreignKey',
  required: true,
},

message: {
  ...mediumMessage,
  required: true,
},

// Optional field (NULL allowed in SQL)
userPkId: {
  ...pkid,
  name: 'userPkId',
  typename: 'foreignKey',
  // required omitted = optional
},

Note: Most standard columns (enabled, createdDate, modifiedDate) are optional in schema even though they're always populated, because SQL allows NULL

Adding New Tables

Steps to add a new table schema:

Add SQL first: Update packages/cwc-database/schema-definition/create-tables.sql
Create schema file: packages/cwc-schema/src/tables/{tableName}.ts
Define schema: Follow existing patterns, use spread syntax for common columns
Add to index: Import and add to schemas.tables object in src/index.ts (alphabetically!)
Add entity type: Create corresponding type in packages/cwc-types/src/entityTypes.ts
Verify alphabetical order: Run validateAlphabeticalOrder() in tests

Template:

'use strict';

import { Schema } from '../types';
import { pkid, enabled, createdDate, modifiedDate } from '../columnTypes';

export const {tableName}Schema: Schema = {
  name: '{tableName}',
  type: 'table',
  version: '1.0.0',
  pkid: '{tableName}PkId',
  columns: {
    {tableName}PkId: { ...pkid, name: '{tableName}PkId' },
    enabled,
    createdDate,
    modifiedDate,
    // ... custom columns
  },
};

Adding New Column Types

When to create a new reusable column type:

Column appears in 3+ tables with identical validation rules
Column has complex validation (regex, specific min/max values)
Column represents a semantic type (email, phone, UUID)

Steps:

Add to src/columnTypes.ts
Export the constant
Use via spread syntax in table schemas

Example:

// columnTypes.ts
export const phoneNumber: SchemaColumn = {
  type: 'string',
  minLength: 10,
  maxLength: 15,
  regex: PHONE_REGEX,
  name: 'phoneNumber',
  typename: 'phoneNumber',
};

// tables/user.ts
phone: { ...phoneNumber, name: 'phone' },

Runtime Validation

Usage:

import { validateEntity, validateColumn, getSchema } from 'cwc-schema';

// Validate a single column
const result = validateColumn('test@example.com', emailColumn);
if (!result.valid) {
  console.error(result.errors);
}

// Validate entire entity
const userSchema = getSchema('user');
const validationResult = validateEntity(userData, userSchema);
if (!validationResult.valid) {
  console.error(validationResult.errors);
}

// Validate partial entity (for updates)
const updateResult = validatePartialEntity({ email: 'new@example.com' }, userSchema);

Validation Functions:

validateColumn(value, column, fieldName?) - Validate single field
validateEntity(data, schema) - Validate complete entity (all required fields)
validatePartialEntity(data, schema) - Validate partial entity (ignores required constraint)

Validation Errors:

type ValidationError = {
  field: string;      // Column name
  message: string;    // Human-readable error
  value?: unknown;    // The invalid value
};

Schema Aggregation

Access schemas:

import { schemas, getSchema, getAllSchemas } from 'cwc-schema';

// Get specific schema by name
const userSchema = getSchema('user');

// Get all schemas as array
const allSchemas = getAllSchemas();

// Access organized by type
const projectSchema = schemas.tables.project;

Helper functions:

getSchema(name: string): Schema | undefined - Find schema by name
getAllSchemas(): Schema[] - Get all schemas (tables + views)
validateAlphabeticalOrder(): void - Throws if schemas not alphabetically ordered

Alphabetical Ordering Requirement

Critical: All table schemas MUST be alphabetically ordered in src/index.ts

Enforcement:

Call validateAlphabeticalOrder() in tests
Throws error with expected vs actual order if violated

Rationale:

Prevents merge conflicts
Makes finding schemas easier
Ensures consistency across the codebase

Column Type Semantic Categories (typename)

Common typenames:

pkid - Primary key or foreign key integer
uuid - UUID v4 identifier (36 chars)
email - Email address
username - Username field
password - Password hash
deviceId - Device UUID
foreignKey - Foreign key reference
boolean - Boolean/TINYINT field
createdDate, modifiedDate, loginDate - Timestamp fields
string - Generic string field
text - Long text field (TEXT type)

Purpose:

Groups similar columns across tables
Enables generic tooling (e.g., admin UI knows how to render 'email' fields)
Self-documenting schema

Regex Patterns

Defined in src/validation/regexPatterns.ts:

EMAIL_REGEX - Email address validation
UUID_REGEX - UUID v4 format
USERNAME_REGEX - Alphanumeric + underscores, 4-100 chars
CONFIRMATION_CODE_REGEX - 6-character codes
PROJECT_ID_REGEX - URL-friendly project identifiers
FILENAME_REGEX - Valid filenames

Usage:

import { EMAIL_REGEX } from 'cwc-schema';

const emailColumn: SchemaColumn = {
  type: 'string',
  regex: EMAIL_REGEX,
  // ...
};

Future Enhancements

Potential future features (not implemented yet):

SQL Generation: Generate CREATE TABLE statements from schema
Type Generation: Generate cwc-types from schema (single source of truth)
Migration Diffing: Compare schema versions to generate migration SQL
Schema Validation: Validate schema matches actual database structure
Admin UI Generation: Auto-generate CRUD interfaces from schema
API Documentation: Generate API docs from schema metadata

Related Packages

Consumed By:

Backend microservices (cwc-api, cwc-sql, cwc-auth) for runtime validation
Future admin tools and generic CRUD interfaces

Depends On:

None (zero runtime dependencies by design)

Related:

cwc-database: SQL scripts are source of truth; schema mirrors them
cwc-types: Provides compile-time types; schema provides runtime validation

Version 2

cwc-schema Package

Database schema definitions with validation rules for the CWC application. Provides a single source of truth for database structure, validation logic, and schema metadata.

Package Purpose

Define database table and view schemas programmatically
Provide runtime validation for entity data
Centralize column definitions and validation rules
Enable schema-driven tooling (future: SQL generation, admin interfaces)
Document database structure in TypeScript

Package Structure

cwc-schema/
├── src/
│   ├── types.ts                  - Core schema type definitions
│   ├── columnTypes.ts            - Reusable column definitions (36 types)
│   ├── validation/
│   │   ├── regexPatterns.ts     - Validation regex constants
│   │   ├── validator.ts         - Runtime validation functions
│   │   └── zodValidators.ts     - Example Zod validators for complex cases
│   ├── tables/                  - Table schema definitions (18 files)
│   │   ├── abuseReport.ts
│   │   ├── adminUser.ts
│   │   ├── ... (alphabetically ordered)
│   │   └── userJwt.ts
│   └── index.ts                 - Schema aggregator and exports
└── dist/                        - Compiled output

Architecture

Relationship to Other Packages

cwc-schema vs cwc-types:

cwc-schema: Validation rules, column metadata, schema structure (this package)
cwc-types: TypeScript entity types for compile-time safety (manually maintained)
Separation: Schema provides runtime validation; types provide compile-time safety
No codegen: Schema does NOT generate cwc-types (both maintained separately for now)
Future: May revisit to have schema generate types as single source of truth

Source of Truth:

Database: SQL scripts in cwc-database remain authoritative for database structure
Schema mirrors SQL: cwc-schema mirrors the SQL definitions for TypeScript/validation purposes
Manual sync: When SQL changes, update both cwc-schema AND cwc-types manually
Future: May transition to schema-first with SQL generation

Core Types

SchemaColumn: Defines a single database column with validation rules

type SchemaColumn = {
  type: 'string' | 'number' | 'boolean' | 'object';
  name: string;                    // Column name in database
  typename: string;                // Semantic category (uuid, email, pkid)
  required?: boolean;              // Whether column is required

  // String validation
  minLength?: number;
  maxLength?: number;
  regex?: RegExp;
  values?: string[];               // Enum values

  // Number validation
  minValue?: number;
  maxValue?: number;

  // Foreign key metadata
  foreignKey?: {
    table: string;
    column: string;
    onDelete?: 'CASCADE' | 'SET NULL' | 'RESTRICT';
  };

  // Hybrid validation (optional Zod)
  zodValidator?: z.ZodType<unknown>;  // When present, Zod validation is used
};

Schema: Defines a complete table or view schema

type Schema = {
  name: string;                    // Table/view name
  type: 'table' | 'view';
  version?: string;                // Schema version (e.g., '1.0.0')
  pkid: string | undefined;        // Primary key column name (undefined for views)
  columns: Record<string, SchemaColumn>;
};

Schema Definition Patterns

Reusable Column Types (Spread Syntax)

Pattern: Define base column types in columnTypes.ts, customize via spread syntax

// columnTypes.ts - Base definition
export const pkid: SchemaColumn = {
  type: 'number',
  name: 'pkid',
  typename: 'pkid',
  minValue: 0,
};

export const uuid: SchemaColumn = {
  type: 'string',
  minLength: 36,
  maxLength: 36,
  regex: UUID_REGEX,
  name: 'uuid',
  typename: 'uuid',
};

// tables/user.ts - Customized usage
userPkId: { ...pkid, name: 'userPkId' },
deviceId: { ...uuid, name: 'deviceId' },

Benefits:

DRY: Validation rules defined once, reused everywhere
Consistency: All UUIDs use same regex, all PKIDs have minValue: 0
Easy updates: Change validation in one place, applies everywhere
Type safety: TypeScript ensures column definitions are valid

Foreign Key Relationships

Pattern: Infer foreign keys from column names ending in PkId (except table's own PkId)

userPkId: {
  ...pkid,
  name: 'userPkId',
  typename: 'foreignKey',
  foreignKey: { table: 'user', column: 'userPkId' },
},

projectPkId: {
  ...pkid,
  name: 'projectPkId',
  typename: 'foreignKey',
  foreignKey: { table: 'project', column: 'projectPkId' },
},

Note: Foreign keys are metadata only; CWC database does NOT use DB-level FK constraints (see cwc-database/CLAUDE.md)

Enum-Like VARCHAR Fields

Pattern: Use values array to define allowed enum values

status: {
  type: 'string',
  typename: 'string',
  minLength: 4,
  maxLength: 25,
  values: ['submitted', 'investigation', 'dismissed', 'resolved', 'retracted'],
  name: 'status',
},

loginType: {
  type: 'string',
  typename: 'string',
  minLength: 3,
  maxLength: 25,
  values: ['cwc', 'facebook', 'google'],
  name: 'loginType',
},

Important: These values must match the potential-values comments in SQL and the union types in cwc-types

Required vs Optional Fields

Pattern: Mark fields as required: true only when they are NOT NULL in SQL AND cannot be null in business logic

// Required field (NOT NULL in SQL)
entityPkId: {
  ...pkid,
  name: 'entityPkId',
  typename: 'foreignKey',
  required: true,
},

message: {
  ...mediumMessage,
  required: true,
},

// Optional field (NULL allowed in SQL)
userPkId: {
  ...pkid,
  name: 'userPkId',
  typename: 'foreignKey',
  // required omitted = optional
},

Note: Most standard columns (enabled, createdDate, modifiedDate) are optional in schema even though they're always populated, because SQL allows NULL

Adding New Tables

Steps to add a new table schema:

Add SQL first: Update packages/cwc-database/schema-definition/create-tables.sql
Create schema file: packages/cwc-schema/src/tables/{tableName}.ts
Define schema: Follow existing patterns, use spread syntax for common columns
Add to index: Import and add to schemas.tables object in src/index.ts (alphabetically!)
Add entity type: Create corresponding type in packages/cwc-types/src/entityTypes.ts
Verify alphabetical order: Run validateAlphabeticalOrder() in tests

Template:

'use strict';

import { Schema } from '../types';
import { pkid, enabled, createdDate, modifiedDate } from '../columnTypes';

export const {tableName}Schema: Schema = {
  name: '{tableName}',
  type: 'table',
  version: '1.0.0',
  pkid: '{tableName}PkId',
  columns: {
    {tableName}PkId: { ...pkid, name: '{tableName}PkId' },
    enabled,
    createdDate,
    modifiedDate,
    // ... custom columns
  },
};

Adding New Column Types

When to create a new reusable column type:

Column appears in 3+ tables with identical validation rules
Column has complex validation (regex, specific min/max values)
Column represents a semantic type (email, phone, UUID)

Steps:

Add to src/columnTypes.ts
Export the constant
Use via spread syntax in table schemas

Example:

// columnTypes.ts
export const phoneNumber: SchemaColumn = {
  type: 'string',
  minLength: 10,
  maxLength: 15,
  regex: PHONE_REGEX,
  name: 'phoneNumber',
  typename: 'phoneNumber',
};

// tables/user.ts
phone: { ...phoneNumber, name: 'phone' },

Runtime Validation

Usage:

import { validateEntity, validateColumn, getSchema } from 'cwc-schema';

// Validate a single column
const result = validateColumn('test@example.com', emailColumn);
if (!result.valid) {
  console.error(result.errors);
}

// Validate entire entity
const userSchema = getSchema('user');
const validationResult = validateEntity(userData, userSchema);
if (!validationResult.valid) {
  console.error(validationResult.errors);
}

// Validate partial entity (for updates)
const updateResult = validatePartialEntity({ email: 'new@example.com' }, userSchema);

Validation Functions:

validateColumn(value, column, fieldName?) - Validate single field
validateEntity(data, schema) - Validate complete entity (all required fields)
validatePartialEntity(data, schema) - Validate partial entity (ignores required constraint)

Validation Errors:

type ValidationError = {
  field: string;      // Column name
  message: string;    // Human-readable error
  value?: unknown;    // The invalid value
};

Hybrid Validation with Zod

Architecture: cwc-schema uses a hybrid validation approach that combines custom validation (default) with optional Zod validators (opt-in).

When to Use Zod vs Custom Validation

Use Zod validators for:

Password strength requirements (uppercase, lowercase, numbers, special chars)
Conditional validation (different rules based on context)
Cross-field validation (one field depends on another)
Complex business logic requiring custom refinements
Advanced string parsing (dates, URLs, transformations)
Nested object/array validation
Profanity filters, blacklists, or complex content rules

Use custom validation for:

Simple min/max length checks
Simple regex patterns (email, UUID, username)
Basic enum values (status, type fields)
Basic type checking (string, number, boolean)
Foreign key references
Most standard columns (enabled, createdDate, etc.)

How Hybrid Validation Works

Custom validation is default: All existing schemas use custom validation
Zod is opt-in: Add zodValidator field to any column to use Zod
No breaking changes: Existing code continues to work unchanged
Validation precedence: When zodValidator is present, Zod is used; otherwise custom validation runs

Adding Zod Validators to Columns

Step 1: Import or create a Zod validator

import { passwordStrengthValidator } from '../validation/zodValidators';

Step 2: Add zodValidator field to column definition

// Before (custom validation)
password: {
  type: 'string',
  minLength: 8,
  maxLength: 100,
  name: 'password',
  typename: 'password',
},

// After (Zod validation)
password: {
  type: 'string',
  minLength: 8,  // Still useful for documentation
  maxLength: 100,
  name: 'password',
  typename: 'password',
  zodValidator: passwordStrengthValidator,  // Zod takes precedence
},

Important: Keep type, minLength, maxLength etc. even when using Zod - they serve as documentation and fallback.

Creating Custom Zod Validators

Example validators are in src/validation/zodValidators.ts:

// Simple password strength validator
export const passwordStrengthValidator = z
  .string()
  .min(8, 'Password must be at least 8 characters')
  .max(100, 'Password must be at most 100 characters')
  .refine((val) => /[A-Z]/.test(val), {
    message: 'Password must contain at least one uppercase letter',
  })
  .refine((val) => /[a-z]/.test(val), {
    message: 'Password must contain at least one lowercase letter',
  })
  .refine((val) => /[0-9]/.test(val), {
    message: 'Password must contain at least one number',
  })
  .refine((val) => /[^A-Za-z0-9]/.test(val), {
    message: 'Password must contain at least one special character',
  });

// Reusable validator factory
export const allowedDomainsUrlValidator = (allowedDomains: string[]) =>
  z
    .string()
    .url('Invalid URL format')
    .refine((val) => val.startsWith('https://'), {
      message: 'URL must use HTTPS',
    })
    .refine(
      (val) => {
        try {
          const url = new URL(val);
          return allowedDomains.some((domain) =>
            url.hostname === domain || url.hostname.endsWith(`.${domain}`)
          );
        } catch {
          return false;
        }
      },
      {
        message: `URL must be from allowed domains: ${allowedDomains.join(', ')}`,
      }
    );

Best Practices

1. Start simple, adopt gradually:

Don't migrate everything to Zod at once
Use Zod only where complexity justifies it
Keep custom validation for simple cases

2. Reuse validators:

Create validator library in zodValidators.ts
Export reusable validators for common patterns
Use factory functions for configurable validators

3. Maintain documentation fields:

Keep minLength, maxLength, values etc. for documentation
These fields help developers understand constraints without reading Zod code
Serves as fallback if Zod validator is removed

4. Error messages:

Provide clear, user-friendly error messages in Zod refinements
Zod errors are automatically converted to ValidationError format
Users see the same error structure regardless of validation method

5. Type safety:

Use z.ZodType<unknown> for the zodValidator field type
TypeScript ensures Zod validators are properly typed
Validation happens at runtime, types are enforced at compile time

Migration Path

Gradual adoption recommended:

Phase 1: Use custom validation for all schemas (current state for most schemas)
Phase 2: Add Zod validators to complex cases (passwords, emails with strict rules)
Phase 3: Evaluate if simple cases benefit from Zod (probably not)
Phase 4: Consider full Zod migration only if benefits are clear

No forced migration: Custom validation remains fully supported and is appropriate for most use cases.

Schema Column Type Definition

type SchemaColumn = {
  // ... existing fields ...

  /**
   * Optional Zod validator for complex validation logic.
   * When present, Zod validation is used instead of custom validation.
   * Allows opt-in to Zod for complex cases while maintaining custom validation as default.
   */
  zodValidator?: z.ZodType<unknown>;
};

Schema Aggregation

Access schemas:

import { schemas, getSchema, getAllSchemas } from 'cwc-schema';

// Get specific schema by name
const userSchema = getSchema('user');

// Get all schemas as array
const allSchemas = getAllSchemas();

// Access organized by type
const projectSchema = schemas.tables.project;

Helper functions:

getSchema(name: string): Schema | undefined - Find schema by name
getAllSchemas(): Schema[] - Get all schemas (tables + views)
validateAlphabeticalOrder(): void - Throws if schemas not alphabetically ordered

Alphabetical Ordering Requirement

Critical: All table schemas MUST be alphabetically ordered in src/index.ts

Enforcement:

Call validateAlphabeticalOrder() in tests
Throws error with expected vs actual order if violated

Rationale:

Prevents merge conflicts
Makes finding schemas easier
Ensures consistency across the codebase

Column Type Semantic Categories (typename)

Common typenames:

pkid - Primary key or foreign key integer
uuid - UUID v4 identifier (36 chars)
email - Email address
username - Username field
password - Password hash
deviceId - Device UUID
foreignKey - Foreign key reference
boolean - Boolean/TINYINT field
createdDate, modifiedDate, loginDate - Timestamp fields
string - Generic string field
text - Long text field (TEXT type)

Purpose:

Groups similar columns across tables
Enables generic tooling (e.g., admin UI knows how to render 'email' fields)
Self-documenting schema

Regex Patterns

Defined in src/validation/regexPatterns.ts:

EMAIL_REGEX - Email address validation
UUID_REGEX - UUID v4 format
USERNAME_REGEX - Alphanumeric + underscores, 4-100 chars
CONFIRMATION_CODE_REGEX - 6-character codes
PROJECT_ID_REGEX - URL-friendly project identifiers
FILENAME_REGEX - Valid filenames

Usage:

import { EMAIL_REGEX } from 'cwc-schema';

const emailColumn: SchemaColumn = {
  type: 'string',
  regex: EMAIL_REGEX,
  // ...
};

Future Enhancements

Potential future features (not implemented yet):

SQL Generation: Generate CREATE TABLE statements from schema
Type Generation: Generate cwc-types from schema (single source of truth)
Migration Diffing: Compare schema versions to generate migration SQL
Schema Validation: Validate schema matches actual database structure
Admin UI Generation: Auto-generate CRUD interfaces from schema
API Documentation: Generate API docs from schema metadata

Related Packages

Consumed By:

Backend microservices (cwc-api, cwc-sql, cwc-auth) for runtime validation
Future admin tools and generic CRUD interfaces

Depends On:

None (zero runtime dependencies by design)

Related:

cwc-database: SQL scripts are source of truth; schema mirrors them
cwc-types: Provides compile-time types; schema provides runtime validation

Version 3

cwc-schema Package

Database schema definitions with validation rules for the CWC application. Provides a single source of truth for database structure, validation logic, and schema metadata.

Package Purpose

Define database table and view schemas programmatically
Provide runtime validation for entity data
Centralize column definitions and validation rules
Enable schema-driven tooling (future: SQL generation, admin interfaces)
Document database structure in TypeScript

Package Structure

cwc-schema/
├── src/
│   ├── types.ts                  - Core schema type definitions
│   ├── columnTypes.ts            - Reusable column definitions (36 types)
│   ├── validation/
│   │   ├── regexPatterns.ts     - Validation regex constants
│   │   ├── validator.ts         - Runtime validation functions
│   │   └── zodValidators.ts     - Example Zod validators for complex cases
│   ├── tables/                  - Table schema definitions (18 files)
│   │   ├── abuseReport.ts
│   │   ├── adminUser.ts
│   │   ├── ... (alphabetically ordered)
│   │   └── userJwt.ts
│   └── index.ts                 - Schema aggregator and exports
└── dist/                        - Compiled output

Architecture

Relationship to Other Packages

cwc-schema vs cwc-types:

cwc-schema: Validation rules, column metadata, schema structure (this package)
cwc-types: TypeScript entity types for compile-time safety (manually maintained)
Separation: Schema provides runtime validation; types provide compile-time safety
No codegen: Schema does NOT generate cwc-types (both maintained separately for now)
Future: May revisit to have schema generate types as single source of truth

Source of Truth:

Database: SQL scripts in cwc-database remain authoritative for database structure
Schema mirrors SQL: cwc-schema mirrors the SQL definitions for TypeScript/validation purposes
Manual sync: When SQL changes, update both cwc-schema AND cwc-types manually
Future: May transition to schema-first with SQL generation

Core Types

SchemaColumn: Defines a single database column with validation rules

type SchemaColumn = {
  type: 'string' | 'number' | 'boolean' | 'object';
  name: string;                    // Column name in database
  typename: string;                // Semantic category (uuid, email, pkid)
  required?: boolean;              // Whether column is required

  // String validation
  minLength?: number;
  maxLength?: number;
  regex?: RegExp;
  values?: string[];               // Enum values

  // Number validation
  minValue?: number;
  maxValue?: number;

  // Foreign key metadata
  foreignKey?: {
    table: string;
    column: string;
    onDelete?: 'CASCADE' | 'SET NULL' | 'RESTRICT';
  };

  // Hybrid validation (optional Zod)
  zodValidator?: z.ZodType<unknown>;  // When present, Zod validation is used
};

Schema: Defines a complete table or view schema

type Schema = {
  name: string;                    // Table/view name
  type: 'table' | 'view';
  version?: string;                // Schema version (e.g., '1.0.0')
  pkid: string | undefined;        // Primary key column name (undefined for views)
  columns: Record<string, SchemaColumn>;
};

Schema Definition Patterns

Reusable Column Types (Spread Syntax)

Pattern: Define base column types in columnTypes.ts, customize via spread syntax

// columnTypes.ts - Base definition
export const pkid: SchemaColumn = {
  type: 'number',
  name: 'pkid',
  typename: 'pkid',
  minValue: 0,
};

export const uuid: SchemaColumn = {
  type: 'string',
  minLength: 36,
  maxLength: 36,
  regex: UUID_REGEX,
  name: 'uuid',
  typename: 'uuid',
};

// tables/user.ts - Customized usage
userPkId: { ...pkid, name: 'userPkId' },
deviceId: { ...uuid, name: 'deviceId' },

Benefits:

DRY: Validation rules defined once, reused everywhere
Consistency: All UUIDs use same regex, all PKIDs have minValue: 0
Easy updates: Change validation in one place, applies everywhere
Type safety: TypeScript ensures column definitions are valid

Foreign Key Relationships

Pattern: Infer foreign keys from column names ending in PkId (except table's own PkId)

userPkId: {
  ...pkid,
  name: 'userPkId',
  typename: 'foreignKey',
  foreignKey: { table: 'user', column: 'userPkId' },
},

projectPkId: {
  ...pkid,
  name: 'projectPkId',
  typename: 'foreignKey',
  foreignKey: { table: 'project', column: 'projectPkId' },
},

Note: Foreign keys are metadata only; CWC database does NOT use DB-level FK constraints (see cwc-database/CLAUDE.md)

Enum-Like VARCHAR Fields

Pattern: Use values array to define allowed enum values

status: {
  type: 'string',
  typename: 'string',
  minLength: 4,
  maxLength: 25,
  values: ['submitted', 'investigation', 'dismissed', 'resolved', 'retracted'],
  name: 'status',
},

loginType: {
  type: 'string',
  typename: 'string',
  minLength: 3,
  maxLength: 25,
  values: ['cwc', 'facebook', 'google'],
  name: 'loginType',
},

Important: These values must match the potential-values comments in SQL and the union types in cwc-types

Required vs Optional Fields

Pattern: Mark fields as required: true only when they are NOT NULL in SQL AND cannot be null in business logic

// Required field (NOT NULL in SQL)
entityPkId: {
  ...pkid,
  name: 'entityPkId',
  typename: 'foreignKey',
  required: true,
},

message: {
  ...mediumMessage,
  required: true,
},

// Optional field (NULL allowed in SQL)
userPkId: {
  ...pkid,
  name: 'userPkId',
  typename: 'foreignKey',
  // required omitted = optional
},

Note: Most standard columns (enabled, createdDate, modifiedDate) are optional in schema even though they're always populated, because SQL allows NULL

Adding New Tables

Steps to add a new table schema:

Add SQL first: Update packages/cwc-database/schema-definition/create-tables.sql
Create schema file: packages/cwc-schema/src/tables/{tableName}.ts
Define schema: Follow existing patterns, use spread syntax for common columns
Add to index: Import and add to schemas.tables object in src/index.ts (alphabetically!)
Add entity type: Create corresponding type in packages/cwc-types/src/entityTypes.ts
Verify alphabetical order: Run validateAlphabeticalOrder() in tests

Template:

'use strict';

import { Schema } from '../types';
import { pkid, enabled, createdDate, modifiedDate } from '../columnTypes';

export const {tableName}Schema: Schema = {
  name: '{tableName}',
  type: 'table',
  version: '1.0.0',
  pkid: '{tableName}PkId',
  columns: {
    {tableName}PkId: { ...pkid, name: '{tableName}PkId' },
    enabled,
    createdDate,
    modifiedDate,
    // ... custom columns
  },
};

Adding New Column Types

When to create a new reusable column type:

Column appears in 3+ tables with identical validation rules
Column has complex validation (regex, specific min/max values)
Column represents a semantic type (email, phone, UUID)

Steps:

Add to src/columnTypes.ts
Export the constant
Use via spread syntax in table schemas

Example:

// columnTypes.ts
export const phoneNumber: SchemaColumn = {
  type: 'string',
  minLength: 10,
  maxLength: 15,
  regex: PHONE_REGEX,
  name: 'phoneNumber',
  typename: 'phoneNumber',
};

// tables/user.ts
phone: { ...phoneNumber, name: 'phone' },

Runtime Validation

Usage:

import { validateEntity, validateColumn, getSchema } from 'cwc-schema';

// Validate a single column
const result = validateColumn('test@example.com', emailColumn);
if (!result.valid) {
  console.error(result.errors);
}

// Validate entire entity
const userSchema = getSchema('user');
const validationResult = validateEntity(userData, userSchema);
if (!validationResult.valid) {
  console.error(validationResult.errors);
}

// Validate partial entity (for updates)
const updateResult = validatePartialEntity({ email: 'new@example.com' }, userSchema);

Validation Functions:

validateColumn(value, column, fieldName?) - Validate single field
validateEntity(data, schema) - Validate complete entity (all required fields)
validatePartialEntity(data, schema) - Validate partial entity (ignores required constraint)

Validation Errors:

type ValidationError = {
  field: string;      // Column name
  message: string;    // Human-readable error
  value?: unknown;    // The invalid value
};

Hybrid Validation with Zod

Architecture: cwc-schema uses a hybrid validation approach that combines custom validation (default) with optional Zod validators (opt-in).

When to Use Zod vs Custom Validation

Use Zod validators for:

Password strength requirements (uppercase, lowercase, numbers, special chars)
Conditional validation (different rules based on context)
Cross-field validation (one field depends on another)
Complex business logic requiring custom refinements
Advanced string parsing (dates, URLs, transformations)
Nested object/array validation
Profanity filters, blacklists, or complex content rules

Use custom validation for:

Simple min/max length checks
Simple regex patterns (email, UUID, username)
Basic enum values (status, type fields)
Basic type checking (string, number, boolean)
Foreign key references
Most standard columns (enabled, createdDate, etc.)

How Hybrid Validation Works

Custom validation is default: All existing schemas use custom validation
Zod is opt-in: Add zodValidator field to any column to use Zod
No breaking changes: Existing code continues to work unchanged
Validation precedence: When zodValidator is present, Zod is used; otherwise custom validation runs

Adding Zod Validators to Columns

Step 1: Import or create a Zod validator

import { passwordStrengthValidator } from '../validation/zodValidators';

Step 2: Add zodValidator field to column definition

// Before (custom validation)
password: {
  type: 'string',
  minLength: 8,
  maxLength: 100,
  name: 'password',
  typename: 'password',
},

// After (Zod validation)
password: {
  type: 'string',
  minLength: 8,  // Still useful for documentation
  maxLength: 100,
  name: 'password',
  typename: 'password',
  zodValidator: passwordStrengthValidator,  // Zod takes precedence
},

Important: Keep type, minLength, maxLength etc. even when using Zod - they serve as documentation and fallback.

Creating Custom Zod Validators

Example validators are in src/validation/zodValidators.ts:

// Simple password strength validator
export const passwordStrengthValidator = z
  .string()
  .min(8, 'Password must be at least 8 characters')
  .max(100, 'Password must be at most 100 characters')
  .refine((val) => /[A-Z]/.test(val), {
    message: 'Password must contain at least one uppercase letter',
  })
  .refine((val) => /[a-z]/.test(val), {
    message: 'Password must contain at least one lowercase letter',
  })
  .refine((val) => /[0-9]/.test(val), {
    message: 'Password must contain at least one number',
  })
  .refine((val) => /[^A-Za-z0-9]/.test(val), {
    message: 'Password must contain at least one special character',
  });

// Reusable validator factory
export const allowedDomainsUrlValidator = (allowedDomains: string[]) =>
  z
    .string()
    .url('Invalid URL format')
    .refine((val) => val.startsWith('https://'), {
      message: 'URL must use HTTPS',
    })
    .refine(
      (val) => {
        try {
          const url = new URL(val);
          return allowedDomains.some((domain) =>
            url.hostname === domain || url.hostname.endsWith(`.${domain}`)
          );
        } catch {
          return false;
        }
      },
      {
        message: `URL must be from allowed domains: ${allowedDomains.join(', ')}`,
      }
    );

Best Practices

1. Start simple, adopt gradually:

Don't migrate everything to Zod at once
Use Zod only where complexity justifies it
Keep custom validation for simple cases

2. Reuse validators:

Create validator library in zodValidators.ts
Export reusable validators for common patterns
Use factory functions for configurable validators

3. Maintain documentation fields:

Keep minLength, maxLength, values etc. for documentation
These fields help developers understand constraints without reading Zod code
Serves as fallback if Zod validator is removed

4. Error messages:

Provide clear, user-friendly error messages in Zod refinements
Zod errors are automatically converted to ValidationError format
Users see the same error structure regardless of validation method

5. Type safety:

Use z.ZodType<unknown> for the zodValidator field type
TypeScript ensures Zod validators are properly typed
Validation happens at runtime, types are enforced at compile time

Migration Path

Gradual adoption recommended:

Phase 1: Use custom validation for all schemas (current state for most schemas)
Phase 2: Add Zod validators to complex cases (passwords, emails with strict rules)
Phase 3: Evaluate if simple cases benefit from Zod (probably not)
Phase 4: Consider full Zod migration only if benefits are clear

No forced migration: Custom validation remains fully supported and is appropriate for most use cases.

Schema Column Type Definition

type SchemaColumn = {
  // ... existing fields ...

  /**
   * Optional Zod validator for complex validation logic.
   * When present, Zod validation is used instead of custom validation.
   * Allows opt-in to Zod for complex cases while maintaining custom validation as default.
   */
  zodValidator?: z.ZodType<unknown>;
};

Schema Aggregation

Access schemas:

import { schemas, getSchema, getAllSchemas } from 'cwc-schema';

// Get specific schema by name
const userSchema = getSchema('user');

// Get all schemas as array
const allSchemas = getAllSchemas();

// Access organized by type
const projectSchema = schemas.tables.project;

Helper functions:

getSchema(name: string): Schema | undefined - Find schema by name
getAllSchemas(): Schema[] - Get all schemas (tables + views)
validateAlphabeticalOrder(): void - Throws if schemas not alphabetically ordered

Alphabetical Ordering Requirement

Critical: All table schemas MUST be alphabetically ordered in src/index.ts

Enforcement:

Call validateAlphabeticalOrder() in tests
Throws error with expected vs actual order if violated

Rationale:

Prevents merge conflicts
Makes finding schemas easier
Ensures consistency across the codebase

Column Type Semantic Categories (typename)

Common typenames:

pkid - Primary key or foreign key integer
uuid - UUID v4 identifier (36 chars)
email - Email address
username - Username field
password - Password hash
deviceId - Device UUID
foreignKey - Foreign key reference
boolean - Boolean/TINYINT field
createdDate, modifiedDate, loginDate - Timestamp fields
string - Generic string field
text - Long text field (TEXT type)

Purpose:

Groups similar columns across tables
Enables generic tooling (e.g., admin UI knows how to render 'email' fields)
Self-documenting schema

Regex Patterns

Defined in src/validation/regexPatterns.ts:

EMAIL_REGEX - Email address validation
UUID_REGEX - UUID v4 format
USERNAME_REGEX - Alphanumeric + underscores, 4-100 chars
CONFIRMATION_CODE_REGEX - 6-character codes
PROJECT_ID_REGEX - URL-friendly project identifiers
FILENAME_REGEX - Valid filenames

Usage:

import { EMAIL_REGEX } from 'cwc-schema';

const emailColumn: SchemaColumn = {
  type: 'string',
  regex: EMAIL_REGEX,
  // ...
};

Future Enhancements

Potential future features (not implemented yet):

SQL Generation: Generate CREATE TABLE statements from schema
Type Generation: Generate cwc-types from schema (single source of truth)
Migration Diffing: Compare schema versions to generate migration SQL
Schema Validation: Validate schema matches actual database structure
Admin UI Generation: Auto-generate CRUD interfaces from schema
API Documentation: Generate API docs from schema metadata

Related Packages

Consumed By:

Backend microservices (cwc-api, cwc-sql, cwc-auth) for runtime validation
Future admin tools and generic CRUD interfaces

Depends On:

None (zero runtime dependencies by design)

Related:

cwc-database: SQL scripts are source of truth; schema mirrors them
cwc-types: Provides compile-time types; schema provides runtime validation

Version 4 (latest)

cwc-schema Package

Database schema definitions with validation rules for the CWC application. Provides a single source of truth for database structure, validation logic, and schema metadata.

Package Purpose

Define database table and view schemas programmatically
Provide runtime validation for entity data
Centralize column definitions and validation rules
Enable schema-driven tooling (future: SQL generation, admin interfaces)
Document database structure in TypeScript

Package Structure

cwc-schema/
├── src/
│   ├── types.ts                  - Core schema type definitions
│   ├── columnTypes.ts            - Reusable column definitions (36 types)
│   ├── validation/
│   │   ├── regexPatterns.ts     - Validation regex constants
│   │   ├── validator.ts         - Runtime validation functions
│   │   └── zodValidators.ts     - Example Zod validators for complex cases
│   ├── tables/                  - Table schema definitions (18 files)
│   │   ├── abuseReport.ts
│   │   ├── adminUser.ts
│   │   ├── ... (alphabetically ordered)
│   │   └── userJwt.ts
│   └── index.ts                 - Schema aggregator and exports
└── dist/                        - Compiled output

Architecture

Relationship to Other Packages

cwc-schema vs cwc-types:

cwc-schema: Validation rules, column metadata, schema structure (this package)
cwc-types: TypeScript entity types for compile-time safety (manually maintained)
Separation: Schema provides runtime validation; types provide compile-time safety
No codegen: Schema does NOT generate cwc-types (both maintained separately for now)
Future: May revisit to have schema generate types as single source of truth

Source of Truth:

Database: SQL scripts in cwc-database remain authoritative for database structure
Schema mirrors SQL: cwc-schema mirrors the SQL definitions for TypeScript/validation purposes
Manual sync: When SQL changes, update both cwc-schema AND cwc-types manually
Future: May transition to schema-first with SQL generation

Core Types

SchemaColumn: Defines a single database column with validation rules

type SchemaColumn = {
  type: 'string' | 'number' | 'boolean' | 'object';
  name: string;                    // Column name in database
  typename: string;                // Semantic category (uuid, email, pkid)
  required?: boolean;              // Whether column is required

  // String validation
  minLength?: number;
  maxLength?: number;
  regex?: RegExp;
  values?: string[];               // Enum values

  // Number validation
  minValue?: number;
  maxValue?: number;

  // Foreign key metadata
  foreignKey?: {
    table: string;
    column: string;
    onDelete?: 'CASCADE' | 'SET NULL' | 'RESTRICT';
  };

  // Hybrid validation (optional Zod)
  zodValidator?: z.ZodType<unknown>;  // When present, Zod validation is used
};

Schema: Defines a complete table or view schema

type Schema = {
  name: string;                    // Table/view name
  type: 'table' | 'view';
  version?: string;                // Schema version (e.g., '1.0.0')
  pkid: string | undefined;        // Primary key column name (undefined for views)
  columns: Record<string, SchemaColumn>;
};

Schema Definition Patterns

Reusable Column Types (Spread Syntax)

Pattern: Define base column types in columnTypes.ts, customize via spread syntax

// columnTypes.ts - Base definition
export const pkid: SchemaColumn = {
  type: 'number',
  name: 'pkid',
  typename: 'pkid',
  minValue: 0,
};

export const uuid: SchemaColumn = {
  type: 'string',
  minLength: 36,
  maxLength: 36,
  regex: UUID_REGEX,
  name: 'uuid',
  typename: 'uuid',
};

// tables/user.ts - Customized usage
userPkId: { ...pkid, name: 'userPkId' },
deviceId: { ...uuid, name: 'deviceId' },

Benefits:

DRY: Validation rules defined once, reused everywhere
Consistency: All UUIDs use same regex, all PKIDs have minValue: 0
Easy updates: Change validation in one place, applies everywhere
Type safety: TypeScript ensures column definitions are valid

Foreign Key Relationships

Pattern: Infer foreign keys from column names ending in PkId (except table's own PkId)

userPkId: {
  ...pkid,
  name: 'userPkId',
  typename: 'foreignKey',
  foreignKey: { table: 'user', column: 'userPkId' },
},

projectPkId: {
  ...pkid,
  name: 'projectPkId',
  typename: 'foreignKey',
  foreignKey: { table: 'project', column: 'projectPkId' },
},

Note: Foreign keys are metadata only; CWC database does NOT use DB-level FK constraints (see cwc-database/CLAUDE.md)

Enum-Like VARCHAR Fields

Pattern: Use values array to define allowed enum values

status: {
  type: 'string',
  typename: 'string',
  minLength: 4,
  maxLength: 25,
  values: ['submitted', 'investigation', 'dismissed', 'resolved', 'retracted'],
  name: 'status',
},

loginType: {
  type: 'string',
  typename: 'string',
  minLength: 3,
  maxLength: 25,
  values: ['cwc', 'facebook', 'google'],
  name: 'loginType',
},

Important: These values must match the potential-values comments in SQL and the union types in cwc-types

Required vs Optional Fields

Pattern: Mark fields as required: true only when they are NOT NULL in SQL AND cannot be null in business logic

// Required field (NOT NULL in SQL)
entityPkId: {
  ...pkid,
  name: 'entityPkId',
  typename: 'foreignKey',
  required: true,
},

message: {
  ...mediumMessage,
  required: true,
},

// Optional field (NULL allowed in SQL)
userPkId: {
  ...pkid,
  name: 'userPkId',
  typename: 'foreignKey',
  // required omitted = optional
},

Note: Most standard columns (enabled, createdDate, modifiedDate) are optional in schema even though they're always populated, because SQL allows NULL

Adding New Tables

Steps to add a new table schema:

Add SQL first: Update packages/cwc-database/schema-definition/create-tables.sql
Create schema file: packages/cwc-schema/src/tables/{tableName}.ts
Define schema: Follow existing patterns, use spread syntax for common columns
Add to index: Import and add to schemas.tables object in src/index.ts (alphabetically!)
Add entity type: Create corresponding type in packages/cwc-types/src/entityTypes.ts
Verify alphabetical order: Run validateAlphabeticalOrder() in tests

Template:

'use strict';

import { Schema } from '../types';
import { pkid, enabled, createdDate, modifiedDate } from '../columnTypes';

export const {tableName}Schema: Schema = {
  name: '{tableName}',
  type: 'table',
  version: '1.0.0',
  pkid: '{tableName}PkId',
  columns: {
    {tableName}PkId: { ...pkid, name: '{tableName}PkId' },
    enabled,
    createdDate,
    modifiedDate,
    // ... custom columns
  },
};

Adding New Column Types

When to create a new reusable column type:

Column appears in 3+ tables with identical validation rules
Column has complex validation (regex, specific min/max values)
Column represents a semantic type (email, phone, UUID)

Steps:

Add to src/columnTypes.ts
Export the constant
Use via spread syntax in table schemas

Example:

// columnTypes.ts
export const phoneNumber: SchemaColumn = {
  type: 'string',
  minLength: 10,
  maxLength: 15,
  regex: PHONE_REGEX,
  name: 'phoneNumber',
  typename: 'phoneNumber',
};

// tables/user.ts
phone: { ...phoneNumber, name: 'phone' },

Runtime Validation

Usage:

import { validateEntity, validateColumn, getSchema } from 'cwc-schema';

// Validate a single column
const result = validateColumn('test@example.com', emailColumn);
if (!result.valid) {
  console.error(result.errors);
}

// Validate entire entity
const userSchema = getSchema('user');
const validationResult = validateEntity(userData, userSchema);
if (!validationResult.valid) {
  console.error(validationResult.errors);
}

// Validate partial entity (for updates)
const updateResult = validatePartialEntity({ email: 'new@example.com' }, userSchema);

Validation Functions:

validateColumn(value, column, fieldName?) - Validate single field
validateEntity(data, schema) - Validate complete entity (all required fields)
validatePartialEntity(data, schema) - Validate partial entity (ignores required constraint)

Validation Errors:

type ValidationError = {
  field: string;      // Column name
  message: string;    // Human-readable error
  value?: unknown;    // The invalid value
};

Hybrid Validation with Zod

Architecture: cwc-schema uses a hybrid validation approach that combines custom validation (default) with optional Zod validators (opt-in).

When to Use Zod vs Custom Validation

Use Zod validators for:

Password strength requirements (uppercase, lowercase, numbers, special chars)
Conditional validation (different rules based on context)
Cross-field validation (one field depends on another)
Complex business logic requiring custom refinements
Advanced string parsing (dates, URLs, transformations)
Nested object/array validation

Use custom validation for:

Simple min/max length checks
Simple regex patterns (email, UUID, username)
Basic enum values (status, type fields)
Basic type checking (string, number, boolean)
Foreign key references
Most standard columns (enabled, createdDate, etc.)

How Hybrid Validation Works

Custom validation is default: All existing schemas use custom validation
Zod is opt-in: Add zodValidator field to any column to use Zod
No breaking changes: Existing code continues to work unchanged
Validation precedence: When zodValidator is present, Zod is used; otherwise custom validation runs

Adding Zod Validators to Columns

Step 1: Import or create a Zod validator

import { passwordStrengthValidator } from '../validation/zodValidators';

Step 2: Add zodValidator field to column definition

// Before (custom validation)
password: {
  type: 'string',
  minLength: 8,
  maxLength: 100,
  name: 'password',
  typename: 'password',
},

// After (Zod validation)
password: {
  type: 'string',
  minLength: 8,  // Still useful for documentation
  maxLength: 100,
  name: 'password',
  typename: 'password',
  zodValidator: passwordStrengthValidator,  // Zod takes precedence
},

Important: Keep type, minLength, maxLength etc. even when using Zod - they serve as documentation and fallback.

Creating Custom Zod Validators

Example validators are in src/validation/zodValidators.ts:

// Simple password strength validator
export const passwordStrengthValidator = z
  .string()
  .min(8, 'Password must be at least 8 characters')
  .max(100, 'Password must be at most 100 characters')
  .refine((val) => /[A-Z]/.test(val), {
    message: 'Password must contain at least one uppercase letter',
  })
  .refine((val) => /[a-z]/.test(val), {
    message: 'Password must contain at least one lowercase letter',
  })
  .refine((val) => /[0-9]/.test(val), {
    message: 'Password must contain at least one number',
  })
  .refine((val) => /[^A-Za-z0-9]/.test(val), {
    message: 'Password must contain at least one special character',
  });

// Reusable validator factory
export const allowedDomainsUrlValidator = (allowedDomains: string[]) =>
  z
    .string()
    .url('Invalid URL format')
    .refine((val) => val.startsWith('https://'), {
      message: 'URL must use HTTPS',
    })
    .refine(
      (val) => {
        try {
          const url = new URL(val);
          return allowedDomains.some((domain) =>
            url.hostname === domain || url.hostname.endsWith(`.${domain}`)
          );
        } catch {
          return false;
        }
      },
      {
        message: `URL must be from allowed domains: ${allowedDomains.join(', ')}`,
      }
    );

Best Practices

1. Start simple, adopt gradually:

Don't migrate everything to Zod at once
Use Zod only where complexity justifies it
Keep custom validation for simple cases

2. Reuse validators:

Create validator library in zodValidators.ts
Export reusable validators for common patterns
Use factory functions for configurable validators

3. Maintain documentation fields:

Keep minLength, maxLength, values etc. for documentation
These fields help developers understand constraints without reading Zod code
Serves as fallback if Zod validator is removed

4. Error messages:

Provide clear, user-friendly error messages in Zod refinements
Zod errors are automatically converted to ValidationError format
Users see the same error structure regardless of validation method

5. Type safety:

Use z.ZodType<unknown> for the zodValidator field type
TypeScript ensures Zod validators are properly typed
Validation happens at runtime, types are enforced at compile time

Migration Path

Gradual adoption recommended:

Phase 1: Use custom validation for all schemas (current state for most schemas)
Phase 2: Add Zod validators to complex cases (passwords, emails with strict rules)
Phase 3: Evaluate if simple cases benefit from Zod (probably not)
Phase 4: Consider full Zod migration only if benefits are clear

No forced migration: Custom validation remains fully supported and is appropriate for most use cases.

Schema Column Type Definition

type SchemaColumn = {
  // ... existing fields ...

  /**
   * Optional Zod validator for complex validation logic.
   * When present, Zod validation is used instead of custom validation.
   * Allows opt-in to Zod for complex cases while maintaining custom validation as default.
   */
  zodValidator?: z.ZodType<unknown>;
};

Schema Aggregation

Access schemas:

import { schemas, getSchema, getAllSchemas } from 'cwc-schema';

// Get specific schema by name
const userSchema = getSchema('user');

// Get all schemas as array
const allSchemas = getAllSchemas();

// Access organized by type
const projectSchema = schemas.tables.project;

Helper functions:

getSchema(name: string): Schema | undefined - Find schema by name
getAllSchemas(): Schema[] - Get all schemas (tables + views)
validateAlphabeticalOrder(): void - Throws if schemas not alphabetically ordered

Alphabetical Ordering Requirement

Critical: All table schemas MUST be alphabetically ordered in src/index.ts

Enforcement:

Call validateAlphabeticalOrder() in tests
Throws error with expected vs actual order if violated

Rationale:

Prevents merge conflicts
Makes finding schemas easier
Ensures consistency across the codebase

Column Type Semantic Categories (typename)

Common typenames:

pkid - Primary key or foreign key integer
uuid - UUID v4 identifier (36 chars)
email - Email address
username - Username field
password - Password hash
deviceId - Device UUID
foreignKey - Foreign key reference
boolean - Boolean/TINYINT field
createdDate, modifiedDate, loginDate - Timestamp fields
string - Generic string field
text - Long text field (TEXT type)

Purpose:

Groups similar columns across tables
Enables generic tooling (e.g., admin UI knows how to render 'email' fields)
Self-documenting schema

Regex Patterns

Defined in src/validation/regexPatterns.ts:

EMAIL_REGEX - Email address validation
UUID_REGEX - UUID v4 format
USERNAME_REGEX - Alphanumeric + underscores, 4-100 chars
CONFIRMATION_CODE_REGEX - 6-character codes
PROJECT_ID_REGEX - URL-friendly project identifiers
FILENAME_REGEX - Valid filenames

Usage:

import { EMAIL_REGEX } from 'cwc-schema';

const emailColumn: SchemaColumn = {
  type: 'string',
  regex: EMAIL_REGEX,
  // ...
};

Future Enhancements

Potential future features (not implemented yet):

SQL Generation: Generate CREATE TABLE statements from schema
Type Generation: Generate cwc-types from schema (single source of truth)
Migration Diffing: Compare schema versions to generate migration SQL
Schema Validation: Validate schema matches actual database structure
Admin UI Generation: Auto-generate CRUD interfaces from schema
API Documentation: Generate API docs from schema metadata

Related Packages

Consumed By:

Backend microservices (cwc-api, cwc-sql, cwc-auth) for runtime validation
Future admin tools and generic CRUD interfaces

Depends On:

None (zero runtime dependencies by design)

Related:

cwc-database: SQL scripts are source of truth; schema mirrors them
cwc-types: Provides compile-time types; schema provides runtime validation

packages/cwc-schema/package.json

3 versions

Version 1

{
  "name": "cwc-schema",
  "version": "1.0.0",
  "description": "Database schema definitions with validation rules for CWC application",
  "type": "module",
  "main": "./dist/index.js",
  "types": "./dist/index.d.ts",
  "exports": {
    ".": {
      "types": "./dist/index.d.ts",
      "default": "./dist/index.js"
    }
  },
  "scripts": {
    "build": "tsc",
    "typecheck": "tsc --noEmit"
  },
  "keywords": ["cwc", "schema", "validation", "database"],
  "author": "",
  "license": "UNLICENSED",
  "devDependencies": {
    "typescript": "^5.4.0"
  }
}

Version 2

{
  "name": "cwc-schema",
  "version": "1.0.0",
  "description": "Database schema definitions with validation rules for CWC application",
  "type": "module",
  "main": "./dist/index.js",
  "types": "./dist/index.d.ts",
  "exports": {
    ".": {
      "types": "./dist/index.d.ts",
      "default": "./dist/index.js"
    }
  },
  "scripts": {
    "build": "tsc",
    "typecheck": "tsc --noEmit"
  },
  "keywords": ["cwc", "schema", "validation", "database"],
  "author": "",
  "license": "UNLICENSED",
  "dependencies": {
    "zod": "^3.24.1"
  },
  "devDependencies": {
    "typescript": "^5.4.0"
  }
}

Version 3 (latest)

{
  "name": "cwc-schema",
  "version": "1.0.0",
  "description": "Database schema definitions with validation rules for CWC application",
  "type": "module",
  "main": "./dist/index.js",
  "types": "./dist/index.d.ts",
  "exports": {
    ".": {
      "types": "./dist/index.d.ts",
      "default": "./dist/index.js"
    }
  },
  "scripts": {
    "build": "tsc",
    "typecheck": "tsc --noEmit"
  },
  "keywords": ["cwc", "schema", "validation", "database"],
  "author": "",
  "license": "UNLICENSED",
  "dependencies": {
    "zod": "^3.24.1"
  },
  "devDependencies": {
    "typescript": "^5.4.0"
  }
}

packages/cwc-schema/src/columnTypes.ts

5 versions

Version 1

'use strict';

import { SchemaColumn } from './types.js';
import {
  EMAIL_REGEX,
  UUID_REGEX,
  USERNAME_REGEX,
  CONFIRMATION_CODE_REGEX,
  PROJECT_ID_REGEX,
  FILENAME_REGEX,
} from './validation/regexPatterns.js';

/**
 * Reusable Column Type Definitions
 *
 * These base column types are used throughout table schemas via spread syntax:
 * Example: userId: { ...uuid, name: 'userId' }
 */

// Primary key (auto-increment integer, always positive)
export const pkid: SchemaColumn = {
  type: 'number',
  name: 'pkid',
  typename: 'pkid',
  minValue: 0,
  // maxValue omitted = unlimited
};

// Boolean (TINYINT in database)
export const boolean: SchemaColumn = {
  type: 'boolean',
  name: 'boolean',
  typename: 'boolean',
};

// Timestamps (DATETIME in database, stored as ISO string)
export const createdDate: SchemaColumn = {
  type: 'string',
  name: 'createdDate',
  typename: 'createdDate',
};

export const modifiedDate: SchemaColumn = {
  type: 'string',
  name: 'modifiedDate',
  typename: 'modifiedDate',
};

export const loginDate: SchemaColumn = {
  type: 'string',
  name: 'loginDate',
  typename: 'loginDate',
};

// UUID identifier (36 characters with hyphens)
export const uuid: SchemaColumn = {
  type: 'string',
  minLength: 36,
  maxLength: 36,
  regex: UUID_REGEX,
  name: 'uuid',
  typename: 'uuid',
};

// Email address (VARCHAR 45)
export const email: SchemaColumn = {
  type: 'string',
  minLength: 5,
  maxLength: 45,
  regex: EMAIL_REGEX,
  name: 'email',
  typename: 'email',
};

// Username (VARCHAR 100 - standard length)
export const username: SchemaColumn = {
  type: 'string',
  minLength: 4,
  maxLength: 100,
  regex: USERNAME_REGEX,
  name: 'username',
  typename: 'username',
};

// Admin username (VARCHAR 25 - shorter for admin accounts)
export const adminUsername: SchemaColumn = {
  type: 'string',
  minLength: 4,
  maxLength: 25,
  regex: USERNAME_REGEX,
  name: 'adminUsername',
  typename: 'adminUsername',
};

// Password hash (VARCHAR 100 - bcrypt/argon2 hash)
export const password: SchemaColumn = {
  type: 'string',
  minLength: 8,
  maxLength: 100,
  name: 'password',
  typename: 'password',
};

// Device ID (UUID format, VARCHAR 36)
export const deviceId: SchemaColumn = {
  type: 'string',
  minLength: 36,
  maxLength: 36,
  regex: UUID_REGEX,
  name: 'deviceId',
  typename: 'deviceId',
};

// Email verification ID (UUID format, VARCHAR 36)
export const emailVerificationId: SchemaColumn = {
  type: 'string',
  minLength: 36,
  maxLength: 36,
  regex: UUID_REGEX,
  name: 'emailVerificationId',
  typename: 'emailVerificationId',
};

// Email confirmation code (6 character alphanumeric)
export const confirmationCode: SchemaColumn = {
  type: 'string',
  minLength: 6,
  maxLength: 6,
  regex: CONFIRMATION_CODE_REGEX,
  name: 'confirmationCode',
  typename: 'confirmationCode',
};

// Email confirmed status
export const emailConfirmed: SchemaColumn = {
  type: 'boolean',
  name: 'emailConfirmed',
  typename: 'emailConfirmed',
};

// Project ID (VARCHAR 150, URL-friendly identifier)
export const projectId: SchemaColumn = {
  type: 'string',
  minLength: 1,
  maxLength: 150,
  regex: PROJECT_ID_REGEX,
  name: 'projectId',
  typename: 'projectId',
};

// Filename (VARCHAR 50)
export const filename: SchemaColumn = {
  type: 'string',
  minLength: 1,
  maxLength: 50,
  regex: FILENAME_REGEX,
  name: 'filename',
  typename: 'filename',
};

// OTP Secret for 2FA (VARCHAR 30)
export const otpSecret: SchemaColumn = {
  type: 'string',
  minLength: 16,
  maxLength: 30,
  name: 'otpSecret',
  typename: 'otpSecret',
};

// OTP Validated status
export const otpValidated: SchemaColumn = {
  type: 'boolean',
  name: 'otpValidated',
  typename: 'otpValidated',
};

// Published status
export const published: SchemaColumn = {
  type: 'boolean',
  name: 'published',
  typename: 'published',
};

// Dismissed status (for error logs)
export const dismissed: SchemaColumn = {
  type: 'boolean',
  name: 'dismissed',
  typename: 'dismissed',
};

// Enabled status (soft delete flag)
export const enabled: SchemaColumn = {
  type: 'boolean',
  name: 'enabled',
  typename: 'enabled',
};

// Display index for ordering (INT)
export const displayIndex: SchemaColumn = {
  type: 'number',
  minValue: 0,
  name: 'displayIndex',
  typename: 'displayIndex',
};

// Image dimensions (INT)
export const height: SchemaColumn = {
  type: 'number',
  minValue: 0,
  name: 'height',
  typename: 'height',
};

export const width: SchemaColumn = {
  type: 'number',
  minValue: 0,
  name: 'width',
  typename: 'width',
};

// Short message/description (VARCHAR 200)
export const shortMessage: SchemaColumn = {
  type: 'string',
  minLength: 1,
  maxLength: 200,
  name: 'message',
  typename: 'shortMessage',
};

// Medium message (VARCHAR 500)
export const mediumMessage: SchemaColumn = {
  type: 'string',
  minLength: 1,
  maxLength: 500,
  name: 'message',
  typename: 'mediumMessage',
};

// Description field (VARCHAR 200)
export const description: SchemaColumn = {
  type: 'string',
  minLength: 1,
  maxLength: 200,
  name: 'description',
  typename: 'description',
};

// Long text field (TEXT)
export const text: SchemaColumn = {
  type: 'string',
  minLength: 1,
  name: 'text',
  typename: 'text',
};

// Code location (VARCHAR 200)
export const codeLocation: SchemaColumn = {
  type: 'string',
  minLength: 1,
  maxLength: 200,
  name: 'codeLocation',
  typename: 'codeLocation',
};

// Service name (VARCHAR 75)
export const serviceName: SchemaColumn = {
  type: 'string',
  minLength: 1,
  maxLength: 75,
  name: 'serviceName',
  typename: 'serviceName',
};

// Feature flag ID (VARCHAR 50)
export const featureFlagId: SchemaColumn = {
  type: 'string',
  minLength: 1,
  maxLength: 50,
  name: 'featureFlagId',
  typename: 'featureFlagId',
};

// MIME type (VARCHAR 100)
export const mimeType: SchemaColumn = {
  type: 'string',
  minLength: 1,
  maxLength: 100,
  name: 'mimeType',
  typename: 'mimeType',
};

// Reaction name (VARCHAR 25)
export const reactionName: SchemaColumn = {
  type: 'string',
  minLength: 1,
  maxLength: 25,
  name: 'reactionName',
  typename: 'reactionName',
};

// Attempt counters (INT)
export const attemptCount: SchemaColumn = {
  type: 'number',
  minValue: 0,
  name: 'attempts',
  typename: 'attemptCount',
};

Version 2

'use strict';

import { SchemaColumn } from './types';
import {
  EMAIL_REGEX,
  UUID_REGEX,
  USERNAME_REGEX,
  CONFIRMATION_CODE_REGEX,
  PROJECT_ID_REGEX,
  FILENAME_REGEX,
} from './validation/regexPatterns';

/**
 * Reusable Column Type Definitions
 *
 * These base column types are used throughout table schemas via spread syntax:
 * Example: userId: { ...uuid, name: 'userId' }
 */

// Primary key (auto-increment integer, always positive)
export const pkid: SchemaColumn = {
  type: 'number',
  name: 'pkid',
  typename: 'pkid',
  minValue: 0,
  // maxValue omitted = unlimited
};

// Boolean (TINYINT in database)
export const boolean: SchemaColumn = {
  type: 'boolean',
  name: 'boolean',
  typename: 'boolean',
};

// Timestamps (DATETIME in database, stored as ISO string)
export const createdDate: SchemaColumn = {
  type: 'string',
  name: 'createdDate',
  typename: 'createdDate',
};

export const modifiedDate: SchemaColumn = {
  type: 'string',
  name: 'modifiedDate',
  typename: 'modifiedDate',
};

export const loginDate: SchemaColumn = {
  type: 'string',
  name: 'loginDate',
  typename: 'loginDate',
};

// UUID identifier (36 characters with hyphens)
export const uuid: SchemaColumn = {
  type: 'string',
  minLength: 36,
  maxLength: 36,
  regex: UUID_REGEX,
  name: 'uuid',
  typename: 'uuid',
};

// Email address (VARCHAR 45)
export const email: SchemaColumn = {
  type: 'string',
  minLength: 5,
  maxLength: 45,
  regex: EMAIL_REGEX,
  name: 'email',
  typename: 'email',
};

// Username (VARCHAR 100 - standard length)
export const username: SchemaColumn = {
  type: 'string',
  minLength: 4,
  maxLength: 100,
  regex: USERNAME_REGEX,
  name: 'username',
  typename: 'username',
};

// Admin username (VARCHAR 25 - shorter for admin accounts)
export const adminUsername: SchemaColumn = {
  type: 'string',
  minLength: 4,
  maxLength: 25,
  regex: USERNAME_REGEX,
  name: 'adminUsername',
  typename: 'adminUsername',
};

// Password hash (VARCHAR 100 - bcrypt/argon2 hash)
export const password: SchemaColumn = {
  type: 'string',
  minLength: 8,
  maxLength: 100,
  name: 'password',
  typename: 'password',
};

// Device ID (UUID format, VARCHAR 36)
export const deviceId: SchemaColumn = {
  type: 'string',
  minLength: 36,
  maxLength: 36,
  regex: UUID_REGEX,
  name: 'deviceId',
  typename: 'deviceId',
};

// Email verification ID (UUID format, VARCHAR 36)
export const emailVerificationId: SchemaColumn = {
  type: 'string',
  minLength: 36,
  maxLength: 36,
  regex: UUID_REGEX,
  name: 'emailVerificationId',
  typename: 'emailVerificationId',
};

// Email confirmation code (6 character alphanumeric)
export const confirmationCode: SchemaColumn = {
  type: 'string',
  minLength: 6,
  maxLength: 6,
  regex: CONFIRMATION_CODE_REGEX,
  name: 'confirmationCode',
  typename: 'confirmationCode',
};

// Email confirmed status
export const emailConfirmed: SchemaColumn = {
  type: 'boolean',
  name: 'emailConfirmed',
  typename: 'emailConfirmed',
};

// Project ID (VARCHAR 150, URL-friendly identifier)
export const projectId: SchemaColumn = {
  type: 'string',
  minLength: 1,
  maxLength: 150,
  regex: PROJECT_ID_REGEX,
  name: 'projectId',
  typename: 'projectId',
};

// Filename (VARCHAR 50)
export const filename: SchemaColumn = {
  type: 'string',
  minLength: 1,
  maxLength: 50,
  regex: FILENAME_REGEX,
  name: 'filename',
  typename: 'filename',
};

// OTP Secret for 2FA (VARCHAR 30)
export const otpSecret: SchemaColumn = {
  type: 'string',
  minLength: 16,
  maxLength: 30,
  name: 'otpSecret',
  typename: 'otpSecret',
};

// OTP Validated status
export const otpValidated: SchemaColumn = {
  type: 'boolean',
  name: 'otpValidated',
  typename: 'otpValidated',
};

// Published status
export const published: SchemaColumn = {
  type: 'boolean',
  name: 'published',
  typename: 'published',
};

// Dismissed status (for error logs)
export const dismissed: SchemaColumn = {
  type: 'boolean',
  name: 'dismissed',
  typename: 'dismissed',
};

// Enabled status (soft delete flag)
export const enabled: SchemaColumn = {
  type: 'boolean',
  name: 'enabled',
  typename: 'enabled',
};

// Display index for ordering (INT)
export const displayIndex: SchemaColumn = {
  type: 'number',
  minValue: 0,
  name: 'displayIndex',
  typename: 'displayIndex',
};

// Image dimensions (INT)
export const height: SchemaColumn = {
  type: 'number',
  minValue: 0,
  name: 'height',
  typename: 'height',
};

export const width: SchemaColumn = {
  type: 'number',
  minValue: 0,
  name: 'width',
  typename: 'width',
};

// Short message/description (VARCHAR 200)
export const shortMessage: SchemaColumn = {
  type: 'string',
  minLength: 1,
  maxLength: 200,
  name: 'message',
  typename: 'shortMessage',
};

// Medium message (VARCHAR 500)
export const mediumMessage: SchemaColumn = {
  type: 'string',
  minLength: 1,
  maxLength: 500,
  name: 'message',
  typename: 'mediumMessage',
};

// Description field (VARCHAR 200)
export const description: SchemaColumn = {
  type: 'string',
  minLength: 1,
  maxLength: 200,
  name: 'description',
  typename: 'description',
};

// Long text field (TEXT)
export const text: SchemaColumn = {
  type: 'string',
  minLength: 1,
  name: 'text',
  typename: 'text',
};

// Code location (VARCHAR 200)
export const codeLocation: SchemaColumn = {
  type: 'string',
  minLength: 1,
  maxLength: 200,
  name: 'codeLocation',
  typename: 'codeLocation',
};

// Service name (VARCHAR 75)
export const serviceName: SchemaColumn = {
  type: 'string',
  minLength: 1,
  maxLength: 75,
  name: 'serviceName',
  typename: 'serviceName',
};

// Feature flag ID (VARCHAR 50)
export const featureFlagId: SchemaColumn = {
  type: 'string',
  minLength: 1,
  maxLength: 50,
  name: 'featureFlagId',
  typename: 'featureFlagId',
};

// MIME type (VARCHAR 100)
export const mimeType: SchemaColumn = {
  type: 'string',
  minLength: 1,
  maxLength: 100,
  name: 'mimeType',
  typename: 'mimeType',
};

// Reaction name (VARCHAR 25)
export const reactionName: SchemaColumn = {
  type: 'string',
  minLength: 1,
  maxLength: 25,
  name: 'reactionName',
  typename: 'reactionName',
};

// Attempt counters (INT)
export const attemptCount: SchemaColumn = {
  type: 'number',
  minValue: 0,
  name: 'attempts',
  typename: 'attemptCount',
};

Version 3

'use strict';

import { SchemaColumn } from './types';
import {
  EMAIL_REGEX,
  UUID_REGEX,
  USERNAME_REGEX,
  CONFIRMATION_CODE_REGEX,
  PROJECT_ID_REGEX,
  FILENAME_REGEX,
} from './validation/regexPatterns';

/**
 * Reusable Column Type Definitions
 *
 * These base column types are used throughout table schemas via spread syntax:
 * Example: userId: { ...uuid, name: 'userId' }
 */

// Primary key (auto-increment integer, database-managed)
export const pkid: SchemaColumn = {
  type: 'number',
  name: 'pkid',
  typename: 'pkid',
  // No validation constraints - database auto-increment handles this
};

// Boolean (TINYINT in database)
export const boolean: SchemaColumn = {
  type: 'boolean',
  name: 'boolean',
  typename: 'boolean',
};

// Timestamps (DATETIME in database, stored as ISO string)
export const createdDate: SchemaColumn = {
  type: 'string',
  name: 'createdDate',
  typename: 'createdDate',
};

export const modifiedDate: SchemaColumn = {
  type: 'string',
  name: 'modifiedDate',
  typename: 'modifiedDate',
};

export const loginDate: SchemaColumn = {
  type: 'string',
  name: 'loginDate',
  typename: 'loginDate',
};

// UUID identifier (36 characters with hyphens)
export const uuid: SchemaColumn = {
  type: 'string',
  minLength: 36,
  maxLength: 36,
  regex: UUID_REGEX,
  name: 'uuid',
  typename: 'uuid',
};

// Email address (VARCHAR 45)
export const email: SchemaColumn = {
  type: 'string',
  minLength: 5,
  maxLength: 45,
  regex: EMAIL_REGEX,
  name: 'email',
  typename: 'email',
};

// Username (VARCHAR 100 - standard length)
export const username: SchemaColumn = {
  type: 'string',
  minLength: 4,
  maxLength: 100,
  regex: USERNAME_REGEX,
  name: 'username',
  typename: 'username',
};

// Admin username (VARCHAR 25 - shorter for admin accounts)
export const adminUsername: SchemaColumn = {
  type: 'string',
  minLength: 4,
  maxLength: 25,
  regex: USERNAME_REGEX,
  name: 'adminUsername',
  typename: 'adminUsername',
};

// Password hash (VARCHAR 100 - bcrypt/argon2 hash)
export const password: SchemaColumn = {
  type: 'string',
  minLength: 8,
  maxLength: 100,
  name: 'password',
  typename: 'password',
};

// Device ID (UUID format, VARCHAR 36)
export const deviceId: SchemaColumn = {
  type: 'string',
  minLength: 36,
  maxLength: 36,
  regex: UUID_REGEX,
  name: 'deviceId',
  typename: 'deviceId',
};

// Email verification ID (UUID format, VARCHAR 36)
export const emailVerificationId: SchemaColumn = {
  type: 'string',
  minLength: 36,
  maxLength: 36,
  regex: UUID_REGEX,
  name: 'emailVerificationId',
  typename: 'emailVerificationId',
};

// Email confirmation code (6 character alphanumeric)
export const confirmationCode: SchemaColumn = {
  type: 'string',
  minLength: 6,
  maxLength: 6,
  regex: CONFIRMATION_CODE_REGEX,
  name: 'confirmationCode',
  typename: 'confirmationCode',
};

// Email confirmed status
export const emailConfirmed: SchemaColumn = {
  type: 'boolean',
  name: 'emailConfirmed',
  typename: 'emailConfirmed',
};

// Project ID (VARCHAR 150, URL-friendly identifier)
export const projectId: SchemaColumn = {
  type: 'string',
  minLength: 1,
  maxLength: 150,
  regex: PROJECT_ID_REGEX,
  name: 'projectId',
  typename: 'projectId',
};

// Filename (VARCHAR 50)
export const filename: SchemaColumn = {
  type: 'string',
  minLength: 1,
  maxLength: 50,
  regex: FILENAME_REGEX,
  name: 'filename',
  typename: 'filename',
};

// OTP Secret for 2FA (VARCHAR 30)
export const otpSecret: SchemaColumn = {
  type: 'string',
  minLength: 16,
  maxLength: 30,
  name: 'otpSecret',
  typename: 'otpSecret',
};

// OTP Validated status
export const otpValidated: SchemaColumn = {
  type: 'boolean',
  name: 'otpValidated',
  typename: 'otpValidated',
};

// Published status
export const published: SchemaColumn = {
  type: 'boolean',
  name: 'published',
  typename: 'published',
};

// Dismissed status (for error logs)
export const dismissed: SchemaColumn = {
  type: 'boolean',
  name: 'dismissed',
  typename: 'dismissed',
};

// Enabled status (soft delete flag)
export const enabled: SchemaColumn = {
  type: 'boolean',
  name: 'enabled',
  typename: 'enabled',
};

// Display index for ordering (INT)
export const displayIndex: SchemaColumn = {
  type: 'number',
  minValue: 0,
  name: 'displayIndex',
  typename: 'displayIndex',
};

// Image dimensions (INT)
export const height: SchemaColumn = {
  type: 'number',
  minValue: 0,
  name: 'height',
  typename: 'height',
};

export const width: SchemaColumn = {
  type: 'number',
  minValue: 0,
  name: 'width',
  typename: 'width',
};

// Short message/description (VARCHAR 200)
export const shortMessage: SchemaColumn = {
  type: 'string',
  minLength: 1,
  maxLength: 200,
  name: 'message',
  typename: 'shortMessage',
};

// Medium message (VARCHAR 500)
export const mediumMessage: SchemaColumn = {
  type: 'string',
  minLength: 1,
  maxLength: 500,
  name: 'message',
  typename: 'mediumMessage',
};

// Description field (VARCHAR 200)
export const description: SchemaColumn = {
  type: 'string',
  minLength: 1,
  maxLength: 200,
  name: 'description',
  typename: 'description',
};

// Long text field (TEXT)
export const text: SchemaColumn = {
  type: 'string',
  minLength: 1,
  name: 'text',
  typename: 'text',
};

// Code location (VARCHAR 200)
export const codeLocation: SchemaColumn = {
  type: 'string',
  minLength: 1,
  maxLength: 200,
  name: 'codeLocation',
  typename: 'codeLocation',
};

// Service name (VARCHAR 75)
export const serviceName: SchemaColumn = {
  type: 'string',
  minLength: 1,
  maxLength: 75,
  name: 'serviceName',
  typename: 'serviceName',
};

// Feature flag ID (VARCHAR 50)
export const featureFlagId: SchemaColumn = {
  type: 'string',
  minLength: 1,
  maxLength: 50,
  name: 'featureFlagId',
  typename: 'featureFlagId',
};

// MIME type (VARCHAR 100)
export const mimeType: SchemaColumn = {
  type: 'string',
  minLength: 1,
  maxLength: 100,
  name: 'mimeType',
  typename: 'mimeType',
};

// Reaction name (VARCHAR 25)
export const reactionName: SchemaColumn = {
  type: 'string',
  minLength: 1,
  maxLength: 25,
  name: 'reactionName',
  typename: 'reactionName',
};

// Attempt counters (INT)
export const attemptCount: SchemaColumn = {
  type: 'number',
  minValue: 1,
  name: 'attempts',
  typename: 'attemptCount',
};

Version 4

'use strict';

import { SchemaColumn } from './types';
import {
  EMAIL_REGEX,
  UUID_REGEX,
  USERNAME_REGEX,
  CONFIRMATION_CODE_REGEX,
  PROJECT_ID_REGEX,
  FILENAME_REGEX,
} from './validation/regexPatterns';

/**
 * Reusable Column Type Definitions
 *
 * These base column types are used throughout table schemas via spread syntax:
 * Example: userId: { ...uuid, name: 'userId' }
 */

// Primary key (auto-increment integer, database-managed)
export const pkid: SchemaColumn = {
  type: 'number',
  name: 'pkid',
  typename: 'pkid',
  // No validation constraints - database auto-increment handles this
};

// Boolean (TINYINT in database)
export const boolean: SchemaColumn = {
  type: 'boolean',
  name: 'boolean',
  typename: 'boolean',
};

// Timestamps (DATETIME in database, stored as ISO string)
export const createdDate: SchemaColumn = {
  type: 'string',
  name: 'createdDate',
  typename: 'createdDate',
};

export const modifiedDate: SchemaColumn = {
  type: 'string',
  name: 'modifiedDate',
  typename: 'modifiedDate',
};

export const loginDate: SchemaColumn = {
  type: 'string',
  name: 'loginDate',
  typename: 'loginDate',
};

// UUID identifier (36 characters with hyphens)
export const uuid: SchemaColumn = {
  type: 'string',
  minLength: 36,
  maxLength: 36,
  regex: UUID_REGEX,
  name: 'uuid',
  typename: 'uuid',
};

// Email address (VARCHAR 45)
export const email: SchemaColumn = {
  type: 'string',
  minLength: 5,
  maxLength: 45,
  regex: EMAIL_REGEX,
  name: 'email',
  typename: 'email',
};

// Username (VARCHAR 100 - standard length)
export const username: SchemaColumn = {
  type: 'string',
  minLength: 4,
  maxLength: 100,
  regex: USERNAME_REGEX,
  name: 'username',
  typename: 'username',
};

// Admin username (VARCHAR 25 - shorter for admin accounts)
export const adminUsername: SchemaColumn = {
  type: 'string',
  minLength: 4,
  maxLength: 25,
  regex: USERNAME_REGEX,
  name: 'adminUsername',
  typename: 'adminUsername',
};

// Password hash (VARCHAR 100 - bcrypt/argon2 hash)
export const password: SchemaColumn = {
  type: 'string',
  minLength: 8,
  maxLength: 100,
  name: 'password',
  typename: 'password',
};

// Device ID (UUID format, VARCHAR 36)
export const deviceId: SchemaColumn = {
  type: 'string',
  minLength: 36,
  maxLength: 36,
  regex: UUID_REGEX,
  name: 'deviceId',
  typename: 'deviceId',
};

// Email verification ID (UUID format, VARCHAR 36)
export const emailVerificationId: SchemaColumn = {
  type: 'string',
  minLength: 36,
  maxLength: 36,
  regex: UUID_REGEX,
  name: 'emailVerificationId',
  typename: 'emailVerificationId',
};

// Email confirmation code (6 character alphanumeric)
export const confirmationCode: SchemaColumn = {
  type: 'string',
  minLength: 6,
  maxLength: 6,
  regex: CONFIRMATION_CODE_REGEX,
  name: 'confirmationCode',
  typename: 'confirmationCode',
};

// Email confirmed status
export const emailConfirmed: SchemaColumn = {
  type: 'boolean',
  name: 'emailConfirmed',
  typename: 'emailConfirmed',
};

// Project ID (VARCHAR 150, URL-friendly identifier)
export const projectId: SchemaColumn = {
  type: 'string',
  minLength: 1,
  maxLength: 150,
  regex: PROJECT_ID_REGEX,
  name: 'projectId',
  typename: 'projectId',
};

// Filename (VARCHAR 50)
export const filename: SchemaColumn = {
  type: 'string',
  minLength: 1,
  maxLength: 50,
  regex: FILENAME_REGEX,
  name: 'filename',
  typename: 'filename',
};

// OTP Secret for 2FA (VARCHAR 30)
export const otpSecret: SchemaColumn = {
  type: 'string',
  minLength: 16,
  maxLength: 30,
  name: 'otpSecret',
  typename: 'otpSecret',
};

// OTP Validated status
export const otpValidated: SchemaColumn = {
  type: 'boolean',
  name: 'otpValidated',
  typename: 'otpValidated',
};

// Published status
export const published: SchemaColumn = {
  type: 'boolean',
  name: 'published',
  typename: 'published',
};

// Dismissed status (for error logs)
export const dismissed: SchemaColumn = {
  type: 'boolean',
  name: 'dismissed',
  typename: 'dismissed',
};

// Enabled status (soft delete flag)
export const enabled: SchemaColumn = {
  type: 'boolean',
  name: 'enabled',
  typename: 'enabled',
};

// Display index for ordering (INT)
export const displayIndex: SchemaColumn = {
  type: 'number',
  minValue: 0,
  name: 'displayIndex',
  typename: 'displayIndex',
};

// Image dimensions (INT)
export const height: SchemaColumn = {
  type: 'number',
  minValue: 0,
  name: 'height',
  typename: 'height',
};

export const width: SchemaColumn = {
  type: 'number',
  minValue: 0,
  name: 'width',
  typename: 'width',
};

// Short message/description (VARCHAR 200)
export const shortMessage: SchemaColumn = {
  type: 'string',
  minLength: 1,
  maxLength: 200,
  name: 'message',
  typename: 'shortMessage',
};

// Medium message (VARCHAR 500)
export const mediumMessage: SchemaColumn = {
  type: 'string',
  minLength: 1,
  maxLength: 500,
  name: 'message',
  typename: 'mediumMessage',
};

// Description field (VARCHAR 200)
export const description: SchemaColumn = {
  type: 'string',
  minLength: 1,
  maxLength: 200,
  name: 'description',
  typename: 'description',
};

// Long text field (TEXT)
export const text: SchemaColumn = {
  type: 'string',
  minLength: 1,
  name: 'text',
  typename: 'text',
};

// Code location (VARCHAR 200)
export const codeLocation: SchemaColumn = {
  type: 'string',
  minLength: 1,
  maxLength: 200,
  name: 'codeLocation',
  typename: 'codeLocation',
};

// Service name (VARCHAR 75)
export const serviceName: SchemaColumn = {
  type: 'string',
  minLength: 1,
  maxLength: 75,
  name: 'serviceName',
  typename: 'serviceName',
};

// Feature flag ID (VARCHAR 50)
export const featureFlagId: SchemaColumn = {
  type: 'string',
  minLength: 1,
  maxLength: 50,
  name: 'featureFlagId',
  typename: 'featureFlagId',
};

// MIME type (VARCHAR 100)
export const mimeType: SchemaColumn = {
  type: 'string',
  minLength: 1,
  maxLength: 100,
  name: 'mimeType',
  typename: 'mimeType',
};

// Reaction name (VARCHAR 25)
export const reactionName: SchemaColumn = {
  type: 'string',
  minLength: 1,
  maxLength: 25,
  name: 'reactionName',
  typename: 'reactionName',
};

// Attempt counters (INT)
export const attemptCount: SchemaColumn = {
  type: 'number',
  minValue: 1,
  name: 'attempts',
  typename: 'attemptCount',
};

// Foreign key to user table
export const userPkId: SchemaColumn = {
  type: 'number',
  name: 'userPkId',
  typename: 'foreignKey',
  foreignKey: { table: 'user', column: 'userPkId' },
};

// Foreign key to project table
export const projectPkId: SchemaColumn = {
  type: 'number',
  name: 'projectPkId',
  typename: 'foreignKey',
  foreignKey: { table: 'project', column: 'projectPkId' },
};

// Foreign key to codingSession table
export const codingSessionPkId: SchemaColumn = {
  type: 'number',
  name: 'codingSessionPkId',
  typename: 'foreignKey',
  foreignKey: { table: 'codingSession', column: 'codingSessionPkId' },
};

// Polymorphic foreign key (generic entity reference)
export const entityPkId: SchemaColumn = {
  type: 'number',
  name: 'entityPkId',
  typename: 'foreignKey',
  required: true,
  // No specific foreignKey.table - polymorphic (could point to multiple tables)
};

// Login type (cwc, facebook, google)
export const loginType: SchemaColumn = {
  type: 'string',
  typename: 'string',
  minLength: 3,
  maxLength: 25,
  values: ['cwc', 'facebook', 'google'],
  name: 'loginType',
};

Version 5 (latest)

'use strict';

import { SchemaColumn } from './types';
import {
  EMAIL_REGEX,
  UUID_REGEX,
  USERNAME_REGEX,
  CONFIRMATION_CODE_REGEX,
  PROJECT_ID_REGEX,
  FILENAME_REGEX,
} from './validation/regexPatterns';

/**
 * Reusable Column Type Definitions
 *
 * These base column types are used throughout table schemas via spread syntax:
 * Example: userId: { ...uuid, name: 'userId' }
 */

// Primary key (auto-increment integer, database-managed)
export const pkid: SchemaColumn = {
  type: 'number',
  name: 'pkid',
  typename: 'pkid',
  // No validation constraints - database auto-increment handles this
};

// Boolean (TINYINT in database)
export const boolean: SchemaColumn = {
  type: 'boolean',
  name: 'boolean',
  typename: 'boolean',
};

// Timestamps (DATETIME in database, stored as ISO string)
export const createdDate: SchemaColumn = {
  type: 'string',
  name: 'createdDate',
  typename: 'createdDate',
};

export const modifiedDate: SchemaColumn = {
  type: 'string',
  name: 'modifiedDate',
  typename: 'modifiedDate',
};

export const loginDate: SchemaColumn = {
  type: 'string',
  name: 'loginDate',
  typename: 'loginDate',
};

// UUID identifier (36 characters with hyphens)
export const uuid: SchemaColumn = {
  type: 'string',
  minLength: 36,
  maxLength: 36,
  regex: UUID_REGEX,
  name: 'uuid',
  typename: 'uuid',
};

// Email address (VARCHAR 45)
export const email: SchemaColumn = {
  type: 'string',
  minLength: 5,
  maxLength: 45,
  regex: EMAIL_REGEX,
  name: 'email',
  typename: 'email',
};

// Username (VARCHAR 100 - standard length)
export const username: SchemaColumn = {
  type: 'string',
  minLength: 4,
  maxLength: 100,
  regex: USERNAME_REGEX,
  name: 'username',
  typename: 'username',
};

// Admin username (VARCHAR 25 - shorter for admin accounts)
export const adminUsername: SchemaColumn = {
  type: 'string',
  minLength: 4,
  maxLength: 25,
  regex: USERNAME_REGEX,
  name: 'adminUsername',
  typename: 'adminUsername',
};

// Password hash (VARCHAR 100 - bcrypt/argon2 hash)
export const password: SchemaColumn = {
  type: 'string',
  minLength: 8,
  maxLength: 100,
  name: 'password',
  typename: 'password',
};

// Device ID (UUID format, VARCHAR 36)
export const deviceId: SchemaColumn = {
  type: 'string',
  minLength: 36,
  maxLength: 36,
  regex: UUID_REGEX,
  name: 'deviceId',
  typename: 'deviceId',
};

// Email verification ID (UUID format, VARCHAR 36)
export const emailVerificationId: SchemaColumn = {
  type: 'string',
  minLength: 36,
  maxLength: 36,
  regex: UUID_REGEX,
  name: 'emailVerificationId',
  typename: 'emailVerificationId',
};

// Email confirmation code (6 character alphanumeric)
export const confirmationCode: SchemaColumn = {
  type: 'string',
  minLength: 6,
  maxLength: 6,
  regex: CONFIRMATION_CODE_REGEX,
  name: 'confirmationCode',
  typename: 'confirmationCode',
};

// Email confirmed status
export const emailConfirmed: SchemaColumn = {
  type: 'boolean',
  name: 'emailConfirmed',
  typename: 'emailConfirmed',
};

// Project ID (VARCHAR 150, URL-friendly identifier)
export const projectId: SchemaColumn = {
  type: 'string',
  minLength: 1,
  maxLength: 150,
  regex: PROJECT_ID_REGEX,
  name: 'projectId',
  typename: 'projectId',
};

// Filename (VARCHAR 50)
export const filename: SchemaColumn = {
  type: 'string',
  minLength: 1,
  maxLength: 50,
  regex: FILENAME_REGEX,
  name: 'filename',
  typename: 'filename',
};

// OTP Secret for 2FA (VARCHAR 30)
export const otpSecret: SchemaColumn = {
  type: 'string',
  minLength: 16,
  maxLength: 30,
  name: 'otpSecret',
  typename: 'otpSecret',
};

// OTP Validated status
export const otpValidated: SchemaColumn = {
  type: 'boolean',
  name: 'otpValidated',
  typename: 'otpValidated',
};

// Published status
export const published: SchemaColumn = {
  type: 'boolean',
  name: 'published',
  typename: 'published',
};

// Dismissed status (for error logs)
export const dismissed: SchemaColumn = {
  type: 'boolean',
  name: 'dismissed',
  typename: 'dismissed',
};

// Enabled status (soft delete flag)
export const enabled: SchemaColumn = {
  type: 'boolean',
  name: 'enabled',
  typename: 'enabled',
};

// Display index for ordering (INT)
export const displayIndex: SchemaColumn = {
  type: 'number',
  minValue: 0,
  name: 'displayIndex',
  typename: 'displayIndex',
};

// Image dimensions (INT)
export const height: SchemaColumn = {
  type: 'number',
  minValue: 0,
  name: 'height',
  typename: 'height',
};

export const width: SchemaColumn = {
  type: 'number',
  minValue: 0,
  name: 'width',
  typename: 'width',
};

// Short message/description (VARCHAR 200)
export const shortMessage: SchemaColumn = {
  type: 'string',
  minLength: 1,
  maxLength: 200,
  name: 'message',
  typename: 'shortMessage',
};

// Medium message (VARCHAR 500)
export const mediumMessage: SchemaColumn = {
  type: 'string',
  minLength: 1,
  maxLength: 500,
  name: 'message',
  typename: 'mediumMessage',
};

// Description field (VARCHAR 200)
export const description: SchemaColumn = {
  type: 'string',
  minLength: 1,
  maxLength: 200,
  name: 'description',
  typename: 'description',
};

// Long text field (TEXT)
export const text: SchemaColumn = {
  type: 'string',
  minLength: 1,
  name: 'text',
  typename: 'text',
};

// Code location (VARCHAR 200)
export const codeLocation: SchemaColumn = {
  type: 'string',
  minLength: 1,
  maxLength: 200,
  name: 'codeLocation',
  typename: 'codeLocation',
};

// Service name (VARCHAR 75)
export const serviceName: SchemaColumn = {
  type: 'string',
  minLength: 1,
  maxLength: 75,
  name: 'serviceName',
  typename: 'serviceName',
};

// Feature flag ID (VARCHAR 50)
export const featureFlagId: SchemaColumn = {
  type: 'string',
  minLength: 1,
  maxLength: 50,
  name: 'featureFlagId',
  typename: 'featureFlagId',
};

// MIME type (VARCHAR 100)
export const mimeType: SchemaColumn = {
  type: 'string',
  minLength: 1,
  maxLength: 100,
  name: 'mimeType',
  typename: 'mimeType',
};

// Reaction name (VARCHAR 25)
export const reactionName: SchemaColumn = {
  type: 'string',
  minLength: 1,
  maxLength: 25,
  name: 'reactionName',
  typename: 'reactionName',
};

// Attempt counters (INT)
export const attemptCount: SchemaColumn = {
  type: 'number',
  minValue: 1,
  name: 'attempts',
  typename: 'attemptCount',
};

// Foreign key to user table
export const userPkId: SchemaColumn = {
  type: 'number',
  name: 'userPkId',
  typename: 'foreignKey',
  foreignKey: { table: 'user', column: 'userPkId' },
};

// Foreign key to project table
export const projectPkId: SchemaColumn = {
  type: 'number',
  name: 'projectPkId',
  typename: 'foreignKey',
  foreignKey: { table: 'project', column: 'projectPkId' },
};

// Foreign key to codingSession table
export const codingSessionPkId: SchemaColumn = {
  type: 'number',
  name: 'codingSessionPkId',
  typename: 'foreignKey',
  foreignKey: { table: 'codingSession', column: 'codingSessionPkId' },
};

// Polymorphic foreign key (generic entity reference)
export const entityPkId: SchemaColumn = {
  type: 'number',
  name: 'entityPkId',
  typename: 'foreignKey',
  required: true,
  // No specific foreignKey.table - polymorphic (could point to multiple tables)
};

// Login type (cwc, facebook, google)
export const loginType: SchemaColumn = {
  type: 'string',
  typename: 'string',
  minLength: 3,
  maxLength: 25,
  values: ['cwc', 'facebook', 'google'],
  name: 'loginType',
};

packages/cwc-schema/src/index.ts

3 versions

Version 1

'use strict';

import { Schema } from './types.js';

// Import all table schemas (alphabetically)
import { abuseReportSchema } from './tables/abuseReport.js';
import { adminUserSchema } from './tables/adminUser.js';
import { adminUserJwtSchema } from './tables/adminUserJwt.js';
import { codingSessionSchema } from './tables/codingSession.js';
import { codingSessionAttachmentSchema } from './tables/codingSessionAttachment.js';
import { codingSessionContentSchema } from './tables/codingSessionContent.js';
import { commentSchema } from './tables/comment.js';
import { contentReportSchema } from './tables/contentReport.js';
import { emailVerifySchema } from './tables/emailVerify.js';
import { errorLogSchema } from './tables/errorLog.js';
import { featureFlagSchema } from './tables/featureFlag.js';
import { passwordResetInfoSchema } from './tables/passwordResetInfo.js';
import { projectSchema } from './tables/project.js';
import { reactionSchema } from './tables/reaction.js';
import { signupInfoSchema } from './tables/signupInfo.js';
import { tempJwtSchema } from './tables/tempJwt.js';
import { userSchema } from './tables/user.js';
import { userJwtSchema } from './tables/userJwt.js';

/**
 * Organized schema structure
 * Separates tables and views for better organization
 */
export const schemas = {
  tables: {
    abuseReport: abuseReportSchema,
    adminUser: adminUserSchema,
    adminUserJwt: adminUserJwtSchema,
    codingSession: codingSessionSchema,
    codingSessionAttachment: codingSessionAttachmentSchema,
    codingSessionContent: codingSessionContentSchema,
    comment: commentSchema,
    contentReport: contentReportSchema,
    emailVerify: emailVerifySchema,
    errorLog: errorLogSchema,
    featureFlag: featureFlagSchema,
    passwordResetInfo: passwordResetInfoSchema,
    project: projectSchema,
    reaction: reactionSchema,
    signupInfo: signupInfoSchema,
    tempJwt: tempJwtSchema,
    user: userSchema,
    userJwt: userJwtSchema,
  },
  views: {
    // Views will be added when create-views.sql is populated
  },
};

/**
 * Get all schemas as a flat array
 */
export const getAllSchemas = (): Schema[] => [
  ...(Object.values(schemas.tables) as Schema[]),
  ...(Object.values(schemas.views) as Schema[]),
];

/**
 * Get a specific schema by name
 */
export const getSchema = (name: string): Schema | undefined => {
  return getAllSchemas().find((schema) => schema.name === name);
};

/**
 * Validate that schemas are in alphabetical order
 * Call this in tests to ensure consistency
 */
export const validateAlphabeticalOrder = (): void => {
  const tableNames = Object.keys(schemas.tables);
  const sortedTableNames = [...tableNames].sort();
  if (JSON.stringify(tableNames) !== JSON.stringify(sortedTableNames)) {
    throw new Error(
      `Table schemas must be alphabetically ordered.\nExpected: ${sortedTableNames.join(', ')}\nActual: ${tableNames.join(', ')}`
    );
  }

  const viewNames = Object.keys(schemas.views);
  const sortedViewNames = [...viewNames].sort();
  if (JSON.stringify(viewNames) !== JSON.stringify(sortedViewNames)) {
    throw new Error(
      `View schemas must be alphabetically ordered.\nExpected: ${sortedViewNames.join(', ')}\nActual: ${viewNames.join(', ')}`
    );
  }
};

// Re-export types for convenience
export * from './types.js';
export * from './columnTypes.js';
export * from './validation/regexPatterns.js';

Version 2

'use strict';

import { Schema } from './types';

// Import all table schemas (alphabetically)
import { abuseReportSchema } from './tables/abuseReport';
import { adminUserSchema } from './tables/adminUser';
import { adminUserJwtSchema } from './tables/adminUserJwt';
import { codingSessionSchema } from './tables/codingSession';
import { codingSessionAttachmentSchema } from './tables/codingSessionAttachment';
import { codingSessionContentSchema } from './tables/codingSessionContent';
import { commentSchema } from './tables/comment';
import { contentReportSchema } from './tables/contentReport';
import { emailVerifySchema } from './tables/emailVerify';
import { errorLogSchema } from './tables/errorLog';
import { featureFlagSchema } from './tables/featureFlag';
import { passwordResetInfoSchema } from './tables/passwordResetInfo';
import { projectSchema } from './tables/project';
import { reactionSchema } from './tables/reaction';
import { signupInfoSchema } from './tables/signupInfo';
import { tempJwtSchema } from './tables/tempJwt';
import { userSchema } from './tables/user';
import { userJwtSchema } from './tables/userJwt';

/**
 * Organized schema structure
 * Separates tables and views for better organization
 */
export const schemas = {
  tables: {
    abuseReport: abuseReportSchema,
    adminUser: adminUserSchema,
    adminUserJwt: adminUserJwtSchema,
    codingSession: codingSessionSchema,
    codingSessionAttachment: codingSessionAttachmentSchema,
    codingSessionContent: codingSessionContentSchema,
    comment: commentSchema,
    contentReport: contentReportSchema,
    emailVerify: emailVerifySchema,
    errorLog: errorLogSchema,
    featureFlag: featureFlagSchema,
    passwordResetInfo: passwordResetInfoSchema,
    project: projectSchema,
    reaction: reactionSchema,
    signupInfo: signupInfoSchema,
    tempJwt: tempJwtSchema,
    user: userSchema,
    userJwt: userJwtSchema,
  },
  views: {
    // Views will be added when create-views.sql is populated
  },
};

/**
 * Get all schemas as a flat array
 */
export const getAllSchemas = (): Schema[] => [
  ...(Object.values(schemas.tables) as Schema[]),
  ...(Object.values(schemas.views) as Schema[]),
];

/**
 * Get a specific schema by name
 */
export const getSchema = (name: string): Schema | undefined => {
  return getAllSchemas().find((schema) => schema.name === name);
};

/**
 * Validate that schemas are in alphabetical order
 * Call this in tests to ensure consistency
 */
export const validateAlphabeticalOrder = (): void => {
  const tableNames = Object.keys(schemas.tables);
  const sortedTableNames = [...tableNames].sort();
  if (JSON.stringify(tableNames) !== JSON.stringify(sortedTableNames)) {
    throw new Error(
      `Table schemas must be alphabetically ordered.\nExpected: ${sortedTableNames.join(', ')}\nActual: ${tableNames.join(', ')}`
    );
  }

  const viewNames = Object.keys(schemas.views);
  const sortedViewNames = [...viewNames].sort();
  if (JSON.stringify(viewNames) !== JSON.stringify(sortedViewNames)) {
    throw new Error(
      `View schemas must be alphabetically ordered.\nExpected: ${sortedViewNames.join(', ')}\nActual: ${viewNames.join(', ')}`
    );
  }
};

// Re-export types for convenience
export * from './types';
export * from './columnTypes';
export * from './validation/regexPatterns';

Version 3 (latest)

'use strict';

import { Schema } from './types';

// Import all table schemas (alphabetically)
import { abuseReportSchema } from './tables/abuseReport';
import { adminUserSchema } from './tables/adminUser';
import { adminUserJwtSchema } from './tables/adminUserJwt';
import { codingSessionSchema } from './tables/codingSession';
import { codingSessionAttachmentSchema } from './tables/codingSessionAttachment';
import { codingSessionContentSchema } from './tables/codingSessionContent';
import { commentSchema } from './tables/comment';
import { contentReportSchema } from './tables/contentReport';
import { emailVerifySchema } from './tables/emailVerify';
import { errorLogSchema } from './tables/errorLog';
import { featureFlagSchema } from './tables/featureFlag';
import { passwordResetInfoSchema } from './tables/passwordResetInfo';
import { projectSchema } from './tables/project';
import { reactionSchema } from './tables/reaction';
import { signupInfoSchema } from './tables/signupInfo';
import { tempJwtSchema } from './tables/tempJwt';
import { userSchema } from './tables/user';
import { userJwtSchema } from './tables/userJwt';

/**
 * Organized schema structure
 * Separates tables and views for better organization
 */
export const schemas = {
  tables: {
    abuseReport: abuseReportSchema,
    adminUser: adminUserSchema,
    adminUserJwt: adminUserJwtSchema,
    codingSession: codingSessionSchema,
    codingSessionAttachment: codingSessionAttachmentSchema,
    codingSessionContent: codingSessionContentSchema,
    comment: commentSchema,
    contentReport: contentReportSchema,
    emailVerify: emailVerifySchema,
    errorLog: errorLogSchema,
    featureFlag: featureFlagSchema,
    passwordResetInfo: passwordResetInfoSchema,
    project: projectSchema,
    reaction: reactionSchema,
    signupInfo: signupInfoSchema,
    tempJwt: tempJwtSchema,
    user: userSchema,
    userJwt: userJwtSchema,
  },
  views: {
    // Views will be added when create-views.sql is populated
  },
};

/**
 * Get all schemas as a flat array
 */
export const getAllSchemas = (): Schema[] => [
  ...(Object.values(schemas.tables) as Schema[]),
  ...(Object.values(schemas.views) as Schema[]),
];

/**
 * Get a specific schema by name
 */
export const getSchema = (name: string): Schema | undefined => {
  return getAllSchemas().find((schema) => schema.name === name);
};

/**
 * Validate that schemas are in alphabetical order
 * Call this in tests to ensure consistency
 */
export const validateAlphabeticalOrder = (): void => {
  const tableNames = Object.keys(schemas.tables);
  const sortedTableNames = [...tableNames].sort();
  if (JSON.stringify(tableNames) !== JSON.stringify(sortedTableNames)) {
    throw new Error(
      `Table schemas must be alphabetically ordered.\nExpected: ${sortedTableNames.join(', ')}\nActual: ${tableNames.join(', ')}`
    );
  }

  const viewNames = Object.keys(schemas.views);
  const sortedViewNames = [...viewNames].sort();
  if (JSON.stringify(viewNames) !== JSON.stringify(sortedViewNames)) {
    throw new Error(
      `View schemas must be alphabetically ordered.\nExpected: ${sortedViewNames.join(', ')}\nActual: ${viewNames.join(', ')}`
    );
  }
};

// Re-export types for convenience
export * from './types';
export * from './columnTypes';
export * from './validation/regexPatterns';

packages/cwc-schema/src/tables/abuseReport.ts

4 versions

Version 1

'use strict';

import { Schema } from '../types.js';
import { pkid, enabled, createdDate, modifiedDate, mediumMessage } from '../columnTypes.js';

export const abuseReportSchema: Schema = {
  name: 'abuseReport',
  type: 'table',
  version: '1.0.0',
  pkid: 'abuseReportPkId',
  columns: {
    abuseReportPkId: { ...pkid, name: 'abuseReportPkId' },
    enabled,
    createdDate,
    modifiedDate,
    userPkId: {
      ...pkid,
      name: 'userPkId',
      typename: 'foreignKey',
      foreignKey: { table: 'user', column: 'userPkId' },
    },
    projectPkId: {
      ...pkid,
      name: 'projectPkId',
      typename: 'foreignKey',
      foreignKey: { table: 'project', column: 'projectPkId' },
    },
    usernames: {
      type: 'string',
      typename: 'string',
      minLength: 1,
      maxLength: 1000,
      name: 'usernames',
      required: true,
    },
    message: {
      ...mediumMessage,
      required: true,
    },
    status: {
      type: 'string',
      typename: 'string',
      minLength: 4,
      maxLength: 25,
      values: ['submitted', 'investigation', 'dismissed', 'resolved', 'retracted'],
      name: 'status',
    },
  },
};

Version 2

'use strict';

import { Schema } from '../types';
import { pkid, enabled, createdDate, modifiedDate, mediumMessage } from '../columnTypes';

export const abuseReportSchema: Schema = {
  name: 'abuseReport',
  type: 'table',
  version: '1.0.0',
  pkid: 'abuseReportPkId',
  columns: {
    abuseReportPkId: { ...pkid, name: 'abuseReportPkId' },
    enabled,
    createdDate,
    modifiedDate,
    userPkId: {
      ...pkid,
      name: 'userPkId',
      typename: 'foreignKey',
      foreignKey: { table: 'user', column: 'userPkId' },
    },
    projectPkId: {
      ...pkid,
      name: 'projectPkId',
      typename: 'foreignKey',
      foreignKey: { table: 'project', column: 'projectPkId' },
    },
    usernames: {
      type: 'string',
      typename: 'string',
      minLength: 1,
      maxLength: 1000,
      name: 'usernames',
      required: true,
    },
    message: {
      ...mediumMessage,
      required: true,
    },
    status: {
      type: 'string',
      typename: 'string',
      minLength: 4,
      maxLength: 25,
      values: ['submitted', 'investigation', 'dismissed', 'resolved', 'retracted'],
      name: 'status',
    },
  },
};

Version 3

'use strict';

import { Schema } from '../types';
import {
  pkid,
  enabled,
  createdDate,
  modifiedDate,
  mediumMessage,
  userPkId,
  projectPkId,
} from '../columnTypes';

export const abuseReportSchema: Schema = {
  name: 'abuseReport',
  type: 'table',
  version: '1.0.0',
  pkid: 'abuseReportPkId',
  columns: {
    abuseReportPkId: { ...pkid, name: 'abuseReportPkId' },
    enabled,
    createdDate,
    modifiedDate,
    userPkId,
    projectPkId,
    usernames: {
      type: 'string',
      typename: 'string',
      minLength: 1,
      maxLength: 1000,
      name: 'usernames',
      required: true,
    },
    message: {
      ...mediumMessage,
      required: true,
    },
    status: {
      type: 'string',
      typename: 'string',
      minLength: 4,
      maxLength: 25,
      values: ['submitted', 'investigation', 'dismissed', 'resolved', 'retracted'],
      name: 'status',
    },
  },
};

Version 4 (latest)

'use strict';

import { Schema } from '../types';
import {
  pkid,
  enabled,
  createdDate,
  modifiedDate,
  mediumMessage,
  userPkId,
  projectPkId,
} from '../columnTypes';

export const abuseReportSchema: Schema = {
  name: 'abuseReport',
  type: 'table',
  version: '1.0.0',
  pkid: 'abuseReportPkId',
  columns: {
    abuseReportPkId: { ...pkid, name: 'abuseReportPkId' },
    enabled,
    createdDate,
    modifiedDate,
    userPkId,
    projectPkId,
    usernames: {
      type: 'string',
      typename: 'string',
      minLength: 1,
      maxLength: 1000,
      name: 'usernames',
      required: true,
    },
    message: {
      ...mediumMessage,
      required: true,
    },
    status: {
      type: 'string',
      typename: 'string',
      minLength: 4,
      maxLength: 25,
      values: ['submitted', 'investigation', 'dismissed', 'resolved', 'retracted'],
      name: 'status',
    },
  },
};

packages/cwc-schema/src/tables/adminUser.ts

3 versions

Version 1

'use strict';

import { Schema } from '../types.js';
import { pkid, enabled, createdDate, modifiedDate, adminUsername, password } from '../columnTypes.js';

export const adminUserSchema: Schema = {
  name: 'adminUser',
  type: 'table',
  version: '1.0.0',
  pkid: 'adminUserPkId',
  columns: {
    adminUserPkId: { ...pkid, name: 'adminUserPkId' },
    enabled,
    createdDate,
    modifiedDate,
    adminUsername,
    password,
  },
};

Version 2

'use strict';

import { Schema } from '../types';
import { pkid, enabled, createdDate, modifiedDate, adminUsername, password } from '../columnTypes';

export const adminUserSchema: Schema = {
  name: 'adminUser',
  type: 'table',
  version: '1.0.0',
  pkid: 'adminUserPkId',
  columns: {
    adminUserPkId: { ...pkid, name: 'adminUserPkId' },
    enabled,
    createdDate,
    modifiedDate,
    adminUsername,
    password,
  },
};

Version 3 (latest)

'use strict';

import { Schema } from '../types';
import { pkid, enabled, createdDate, modifiedDate, adminUsername, password } from '../columnTypes';

export const adminUserSchema: Schema = {
  name: 'adminUser',
  type: 'table',
  version: '1.0.0',
  pkid: 'adminUserPkId',
  columns: {
    adminUserPkId: { ...pkid, name: 'adminUserPkId' },
    enabled,
    createdDate,
    modifiedDate,
    adminUsername,
    password,
  },
};

packages/cwc-schema/src/tables/adminUserJwt.ts

3 versions

Version 1

'use strict';

import { Schema } from '../types.js';
import { pkid, enabled, createdDate, modifiedDate, uuid } from '../columnTypes.js';

export const adminUserJwtSchema: Schema = {
  name: 'adminUserJwt',
  type: 'table',
  version: '1.0.0',
  pkid: 'adminUserJwtPkId',
  columns: {
    adminUserJwtPkId: { ...pkid, name: 'adminUserJwtPkId' },
    enabled,
    createdDate,
    modifiedDate,
    adminUserJwtId: { ...uuid, name: 'adminUserJwtId' },
  },
};

Version 2

'use strict';

import { Schema } from '../types';
import { pkid, enabled, createdDate, modifiedDate, uuid } from '../columnTypes';

export const adminUserJwtSchema: Schema = {
  name: 'adminUserJwt',
  type: 'table',
  version: '1.0.0',
  pkid: 'adminUserJwtPkId',
  columns: {
    adminUserJwtPkId: { ...pkid, name: 'adminUserJwtPkId' },
    enabled,
    createdDate,
    modifiedDate,
    adminUserJwtId: { ...uuid, name: 'adminUserJwtId' },
  },
};

Version 3 (latest)

'use strict';

import { Schema } from '../types';
import { pkid, enabled, createdDate, modifiedDate, uuid } from '../columnTypes';

export const adminUserJwtSchema: Schema = {
  name: 'adminUserJwt',
  type: 'table',
  version: '1.0.0',
  pkid: 'adminUserJwtPkId',
  columns: {
    adminUserJwtPkId: { ...pkid, name: 'adminUserJwtPkId' },
    enabled,
    createdDate,
    modifiedDate,
    adminUserJwtId: { ...uuid, name: 'adminUserJwtId' },
  },
};

packages/cwc-schema/src/tables/codingSession.ts

4 versions

Version 1

'use strict';

import { Schema } from '../types.js';
import { pkid, enabled, createdDate, modifiedDate, text, published } from '../columnTypes.js';

export const codingSessionSchema: Schema = {
  name: 'codingSession',
  type: 'table',
  version: '1.0.0',
  pkid: 'codingSessionPkId',
  columns: {
    codingSessionPkId: { ...pkid, name: 'codingSessionPkId' },
    enabled,
    createdDate,
    modifiedDate,
    userPkId: {
      ...pkid,
      name: 'userPkId',
      typename: 'foreignKey',
      foreignKey: { table: 'user', column: 'userPkId' },
    },
    projectPkId: {
      ...pkid,
      name: 'projectPkId',
      typename: 'foreignKey',
      foreignKey: { table: 'project', column: 'projectPkId' },
    },
    description: { ...text, name: 'description' },
    published,
  },
};

Version 2

'use strict';

import { Schema } from '../types';
import { pkid, enabled, createdDate, modifiedDate, text, published } from '../columnTypes';

export const codingSessionSchema: Schema = {
  name: 'codingSession',
  type: 'table',
  version: '1.0.0',
  pkid: 'codingSessionPkId',
  columns: {
    codingSessionPkId: { ...pkid, name: 'codingSessionPkId' },
    enabled,
    createdDate,
    modifiedDate,
    userPkId: {
      ...pkid,
      name: 'userPkId',
      typename: 'foreignKey',
      foreignKey: { table: 'user', column: 'userPkId' },
    },
    projectPkId: {
      ...pkid,
      name: 'projectPkId',
      typename: 'foreignKey',
      foreignKey: { table: 'project', column: 'projectPkId' },
    },
    description: { ...text, name: 'description' },
    published,
  },
};

Version 3

'use strict';

import { Schema } from '../types';
import {
  pkid,
  enabled,
  createdDate,
  modifiedDate,
  text,
  published,
  userPkId,
  projectPkId,
} from '../columnTypes';

export const codingSessionSchema: Schema = {
  name: 'codingSession',
  type: 'table',
  version: '1.0.0',
  pkid: 'codingSessionPkId',
  columns: {
    codingSessionPkId: { ...pkid, name: 'codingSessionPkId' },
    enabled,
    createdDate,
    modifiedDate,
    userPkId,
    projectPkId,
    description: { ...text, name: 'description' },
    published,
  },
};

Version 4 (latest)

'use strict';

import { Schema } from '../types';
import {
  pkid,
  enabled,
  createdDate,
  modifiedDate,
  text,
  published,
  userPkId,
  projectPkId,
} from '../columnTypes';

export const codingSessionSchema: Schema = {
  name: 'codingSession',
  type: 'table',
  version: '1.0.0',
  pkid: 'codingSessionPkId',
  columns: {
    codingSessionPkId: { ...pkid, name: 'codingSessionPkId' },
    enabled,
    createdDate,
    modifiedDate,
    userPkId,
    projectPkId,
    description: { ...text, name: 'description' },
    published,
  },
};

packages/cwc-schema/src/tables/codingSessionAttachment.ts

4 versions

Version 1

'use strict';

import { Schema } from '../types.js';
import {
  pkid,
  enabled,
  createdDate,
  modifiedDate,
  filename,
  mimeType,
  height,
  width,
} from '../columnTypes.js';

export const codingSessionAttachmentSchema: Schema = {
  name: 'codingSessionAttachment',
  type: 'table',
  version: '1.0.0',
  pkid: 'codingSessionAttachmentPkId',
  columns: {
    codingSessionAttachmentPkId: { ...pkid, name: 'codingSessionAttachmentPkId' },
    enabled,
    createdDate,
    modifiedDate,
    userPkId: {
      ...pkid,
      name: 'userPkId',
      typename: 'foreignKey',
      foreignKey: { table: 'user', column: 'userPkId' },
    },
    projectPkId: {
      ...pkid,
      name: 'projectPkId',
      typename: 'foreignKey',
      foreignKey: { table: 'project', column: 'projectPkId' },
    },
    codingSessionPkId: {
      ...pkid,
      name: 'codingSessionPkId',
      typename: 'foreignKey',
      foreignKey: { table: 'codingSession', column: 'codingSessionPkId' },
    },
    filename,
    mimeType: {
      ...mimeType,
      values: ['image/png', 'image/jpg'],
    },
    height,
    width,
  },
};

Version 2

'use strict';

import { Schema } from '../types';
import {
  pkid,
  enabled,
  createdDate,
  modifiedDate,
  filename,
  mimeType,
  height,
  width,
} from '../columnTypes';

export const codingSessionAttachmentSchema: Schema = {
  name: 'codingSessionAttachment',
  type: 'table',
  version: '1.0.0',
  pkid: 'codingSessionAttachmentPkId',
  columns: {
    codingSessionAttachmentPkId: { ...pkid, name: 'codingSessionAttachmentPkId' },
    enabled,
    createdDate,
    modifiedDate,
    userPkId: {
      ...pkid,
      name: 'userPkId',
      typename: 'foreignKey',
      foreignKey: { table: 'user', column: 'userPkId' },
    },
    projectPkId: {
      ...pkid,
      name: 'projectPkId',
      typename: 'foreignKey',
      foreignKey: { table: 'project', column: 'projectPkId' },
    },
    codingSessionPkId: {
      ...pkid,
      name: 'codingSessionPkId',
      typename: 'foreignKey',
      foreignKey: { table: 'codingSession', column: 'codingSessionPkId' },
    },
    filename,
    mimeType: {
      ...mimeType,
      values: ['image/png', 'image/jpg'],
    },
    height,
    width,
  },
};

Version 3

'use strict';

import { Schema } from '../types';
import {
  pkid,
  enabled,
  createdDate,
  modifiedDate,
  filename,
  mimeType,
  height,
  width,
  userPkId,
  projectPkId,
  codingSessionPkId,
} from '../columnTypes';

export const codingSessionAttachmentSchema: Schema = {
  name: 'codingSessionAttachment',
  type: 'table',
  version: '1.0.0',
  pkid: 'codingSessionAttachmentPkId',
  columns: {
    codingSessionAttachmentPkId: { ...pkid, name: 'codingSessionAttachmentPkId' },
    enabled,
    createdDate,
    modifiedDate,
    userPkId,
    projectPkId,
    codingSessionPkId,
    filename,
    mimeType: {
      ...mimeType,
      values: ['image/png', 'image/jpg'],
    },
    height,
    width,
  },
};

Version 4 (latest)

'use strict';

import { Schema } from '../types';
import {
  pkid,
  enabled,
  createdDate,
  modifiedDate,
  filename,
  mimeType,
  height,
  width,
  userPkId,
  projectPkId,
  codingSessionPkId,
} from '../columnTypes';

export const codingSessionAttachmentSchema: Schema = {
  name: 'codingSessionAttachment',
  type: 'table',
  version: '1.0.0',
  pkid: 'codingSessionAttachmentPkId',
  columns: {
    codingSessionAttachmentPkId: { ...pkid, name: 'codingSessionAttachmentPkId' },
    enabled,
    createdDate,
    modifiedDate,
    userPkId,
    projectPkId,
    codingSessionPkId,
    filename,
    mimeType: {
      ...mimeType,
      values: ['image/png', 'image/jpg'],
    },
    height,
    width,
  },
};

packages/cwc-schema/src/tables/codingSessionContent.ts

4 versions

Version 1

'use strict';

import { Schema } from '../types.js';
import { pkid, enabled, createdDate, modifiedDate, text, displayIndex } from '../columnTypes.js';

export const codingSessionContentSchema: Schema = {
  name: 'codingSessionContent',
  type: 'table',
  version: '1.0.0',
  pkid: 'codingSessionContentPkId',
  columns: {
    codingSessionContentPkId: { ...pkid, name: 'codingSessionContentPkId' },
    enabled,
    createdDate,
    modifiedDate,
    userPkId: {
      ...pkid,
      name: 'userPkId',
      typename: 'foreignKey',
      foreignKey: { table: 'user', column: 'userPkId' },
    },
    projectPkId: {
      ...pkid,
      name: 'projectPkId',
      typename: 'foreignKey',
      foreignKey: { table: 'project', column: 'projectPkId' },
    },
    contentType: {
      type: 'string',
      typename: 'string',
      minLength: 4,
      maxLength: 25,
      values: ['prompt', 'response', 'note', 'attachment'],
      name: 'contentType',
    },
    codingSessionPkId: {
      ...pkid,
      name: 'codingSessionPkId',
      typename: 'foreignKey',
      foreignKey: { table: 'codingSession', column: 'codingSessionPkId' },
    },
    codingSessionAttachmentPkId: {
      ...pkid,
      name: 'codingSessionAttachmentPkId',
      typename: 'foreignKey',
      foreignKey: { table: 'codingSessionAttachment', column: 'codingSessionAttachmentPkId' },
    },
    displayIndex,
    text,
  },
};

Version 2

'use strict';

import { Schema } from '../types';
import { pkid, enabled, createdDate, modifiedDate, text, displayIndex } from '../columnTypes';

export const codingSessionContentSchema: Schema = {
  name: 'codingSessionContent',
  type: 'table',
  version: '1.0.0',
  pkid: 'codingSessionContentPkId',
  columns: {
    codingSessionContentPkId: { ...pkid, name: 'codingSessionContentPkId' },
    enabled,
    createdDate,
    modifiedDate,
    userPkId: {
      ...pkid,
      name: 'userPkId',
      typename: 'foreignKey',
      foreignKey: { table: 'user', column: 'userPkId' },
    },
    projectPkId: {
      ...pkid,
      name: 'projectPkId',
      typename: 'foreignKey',
      foreignKey: { table: 'project', column: 'projectPkId' },
    },
    contentType: {
      type: 'string',
      typename: 'string',
      minLength: 4,
      maxLength: 25,
      values: ['prompt', 'response', 'note', 'attachment'],
      name: 'contentType',
    },
    codingSessionPkId: {
      ...pkid,
      name: 'codingSessionPkId',
      typename: 'foreignKey',
      foreignKey: { table: 'codingSession', column: 'codingSessionPkId' },
    },
    codingSessionAttachmentPkId: {
      ...pkid,
      name: 'codingSessionAttachmentPkId',
      typename: 'foreignKey',
      foreignKey: { table: 'codingSessionAttachment', column: 'codingSessionAttachmentPkId' },
    },
    displayIndex,
    text,
  },
};

Version 3

'use strict';

import { Schema } from '../types';
import {
  pkid,
  enabled,
  createdDate,
  modifiedDate,
  text,
  displayIndex,
  userPkId,
  projectPkId,
  codingSessionPkId,
} from '../columnTypes';

export const codingSessionContentSchema: Schema = {
  name: 'codingSessionContent',
  type: 'table',
  version: '1.0.0',
  pkid: 'codingSessionContentPkId',
  columns: {
    codingSessionContentPkId: { ...pkid, name: 'codingSessionContentPkId' },
    enabled,
    createdDate,
    modifiedDate,
    userPkId,
    projectPkId,
    contentType: {
      type: 'string',
      typename: 'string',
      minLength: 4,
      maxLength: 25,
      values: ['prompt', 'response', 'note', 'attachment'],
      name: 'contentType',
    },
    codingSessionPkId,
    codingSessionAttachmentPkId: {
      ...pkid,
      name: 'codingSessionAttachmentPkId',
      typename: 'foreignKey',
      foreignKey: { table: 'codingSessionAttachment', column: 'codingSessionAttachmentPkId' },
    },
    displayIndex,
    text,
  },
};

Version 4 (latest)

'use strict';

import { Schema } from '../types';
import {
  pkid,
  enabled,
  createdDate,
  modifiedDate,
  text,
  displayIndex,
  userPkId,
  projectPkId,
  codingSessionPkId,
} from '../columnTypes';

export const codingSessionContentSchema: Schema = {
  name: 'codingSessionContent',
  type: 'table',
  version: '1.0.0',
  pkid: 'codingSessionContentPkId',
  columns: {
    codingSessionContentPkId: { ...pkid, name: 'codingSessionContentPkId' },
    enabled,
    createdDate,
    modifiedDate,
    userPkId,
    projectPkId,
    contentType: {
      type: 'string',
      typename: 'string',
      minLength: 4,
      maxLength: 25,
      values: ['prompt', 'response', 'note', 'attachment'],
      name: 'contentType',
    },
    codingSessionPkId,
    codingSessionAttachmentPkId: {
      ...pkid,
      name: 'codingSessionAttachmentPkId',
      typename: 'foreignKey',
      foreignKey: { table: 'codingSessionAttachment', column: 'codingSessionAttachmentPkId' },
    },
    displayIndex,
    text,
  },
};

packages/cwc-schema/src/tables/comment.ts

4 versions

Version 1

'use strict';

import { Schema } from '../types.js';
import { pkid, enabled, createdDate, modifiedDate, text } from '../columnTypes.js';

export const commentSchema: Schema = {
  name: 'comment',
  type: 'table',
  version: '1.0.0',
  pkid: 'commentPkId',
  columns: {
    commentPkId: { ...pkid, name: 'commentPkId' },
    enabled,
    createdDate,
    modifiedDate,
    projectPkId: {
      ...pkid,
      name: 'projectPkId',
      typename: 'foreignKey',
      foreignKey: { table: 'project', column: 'projectPkId' },
    },
    userPkId: {
      ...pkid,
      name: 'userPkId',
      typename: 'foreignKey',
      foreignKey: { table: 'user', column: 'userPkId' },
    },
    entityPkId: {
      ...pkid,
      name: 'entityPkId',
      typename: 'foreignKey',
      required: true,
    },
    entityType: {
      type: 'string',
      typename: 'string',
      minLength: 7,
      maxLength: 50,
      values: ['project', 'codingSession', 'codingSessionContent', 'codingSessionAttachment', 'comment'],
      name: 'entityType',
      required: true,
    },
    text,
  },
};

Version 2

'use strict';

import { Schema } from '../types';
import { pkid, enabled, createdDate, modifiedDate, text } from '../columnTypes';

export const commentSchema: Schema = {
  name: 'comment',
  type: 'table',
  version: '1.0.0',
  pkid: 'commentPkId',
  columns: {
    commentPkId: { ...pkid, name: 'commentPkId' },
    enabled,
    createdDate,
    modifiedDate,
    projectPkId: {
      ...pkid,
      name: 'projectPkId',
      typename: 'foreignKey',
      foreignKey: { table: 'project', column: 'projectPkId' },
    },
    userPkId: {
      ...pkid,
      name: 'userPkId',
      typename: 'foreignKey',
      foreignKey: { table: 'user', column: 'userPkId' },
    },
    entityPkId: {
      ...pkid,
      name: 'entityPkId',
      typename: 'foreignKey',
      required: true,
    },
    entityType: {
      type: 'string',
      typename: 'string',
      minLength: 7,
      maxLength: 50,
      values: ['project', 'codingSession', 'codingSessionContent', 'codingSessionAttachment', 'comment'],
      name: 'entityType',
      required: true,
    },
    text,
  },
};

Version 3

'use strict';

import { Schema } from '../types';
import {
  pkid,
  enabled,
  createdDate,
  modifiedDate,
  text,
  userPkId,
  projectPkId,
  entityPkId,
} from '../columnTypes';

export const commentSchema: Schema = {
  name: 'comment',
  type: 'table',
  version: '1.0.0',
  pkid: 'commentPkId',
  columns: {
    commentPkId: { ...pkid, name: 'commentPkId' },
    enabled,
    createdDate,
    modifiedDate,
    projectPkId,
    userPkId,
    entityPkId,
    entityType: {
      type: 'string',
      typename: 'string',
      minLength: 7,
      maxLength: 50,
      values: ['project', 'codingSession', 'codingSessionContent', 'codingSessionAttachment', 'comment'],
      name: 'entityType',
      required: true,
    },
    text,
  },
};

Version 4 (latest)

'use strict';

import { Schema } from '../types';
import {
  pkid,
  enabled,
  createdDate,
  modifiedDate,
  text,
  userPkId,
  projectPkId,
  entityPkId,
} from '../columnTypes';

export const commentSchema: Schema = {
  name: 'comment',
  type: 'table',
  version: '1.0.0',
  pkid: 'commentPkId',
  columns: {
    commentPkId: { ...pkid, name: 'commentPkId' },
    enabled,
    createdDate,
    modifiedDate,
    projectPkId,
    userPkId,
    entityPkId,
    entityType: {
      type: 'string',
      typename: 'string',
      minLength: 7,
      maxLength: 50,
      values: ['project', 'codingSession', 'codingSessionContent', 'codingSessionAttachment', 'comment'],
      name: 'entityType',
      required: true,
    },
    text,
  },
};

packages/cwc-schema/src/tables/contentReport.ts

4 versions

Version 1

'use strict';

import { Schema } from '../types.js';
import { pkid, enabled, createdDate, modifiedDate, mediumMessage } from '../columnTypes.js';

export const contentReportSchema: Schema = {
  name: 'contentReport',
  type: 'table',
  version: '1.0.0',
  pkid: 'contentReportPkId',
  columns: {
    contentReportPkId: { ...pkid, name: 'contentReportPkId' },
    enabled,
    createdDate,
    modifiedDate,
    userPkId: {
      ...pkid,
      name: 'userPkId',
      typename: 'foreignKey',
      foreignKey: { table: 'user', column: 'userPkId' },
    },
    projectPkId: {
      ...pkid,
      name: 'projectPkId',
      typename: 'foreignKey',
      foreignKey: { table: 'project', column: 'projectPkId' },
    },
    entityPkId: {
      ...pkid,
      name: 'entityPkId',
      typename: 'foreignKey',
      required: true,
    },
    entityType: {
      type: 'string',
      typename: 'string',
      minLength: 7,
      maxLength: 50,
      values: ['project', 'codingSession', 'codingSessionContent', 'codingSessionAttachment', 'comment'],
      name: 'entityType',
      required: true,
    },
    message: {
      ...mediumMessage,
      required: true,
    },
    status: {
      type: 'string',
      typename: 'string',
      minLength: 4,
      maxLength: 25,
      values: ['submitted', 'investigation', 'dismissed', 'resolved', 'retracted'],
      name: 'status',
    },
  },
};

Version 2

'use strict';

import { Schema } from '../types';
import { pkid, enabled, createdDate, modifiedDate, mediumMessage } from '../columnTypes';

export const contentReportSchema: Schema = {
  name: 'contentReport',
  type: 'table',
  version: '1.0.0',
  pkid: 'contentReportPkId',
  columns: {
    contentReportPkId: { ...pkid, name: 'contentReportPkId' },
    enabled,
    createdDate,
    modifiedDate,
    userPkId: {
      ...pkid,
      name: 'userPkId',
      typename: 'foreignKey',
      foreignKey: { table: 'user', column: 'userPkId' },
    },
    projectPkId: {
      ...pkid,
      name: 'projectPkId',
      typename: 'foreignKey',
      foreignKey: { table: 'project', column: 'projectPkId' },
    },
    entityPkId: {
      ...pkid,
      name: 'entityPkId',
      typename: 'foreignKey',
      required: true,
    },
    entityType: {
      type: 'string',
      typename: 'string',
      minLength: 7,
      maxLength: 50,
      values: ['project', 'codingSession', 'codingSessionContent', 'codingSessionAttachment', 'comment'],
      name: 'entityType',
      required: true,
    },
    message: {
      ...mediumMessage,
      required: true,
    },
    status: {
      type: 'string',
      typename: 'string',
      minLength: 4,
      maxLength: 25,
      values: ['submitted', 'investigation', 'dismissed', 'resolved', 'retracted'],
      name: 'status',
    },
  },
};

Version 3

'use strict';

import { Schema } from '../types';
import {
  pkid,
  enabled,
  createdDate,
  modifiedDate,
  mediumMessage,
  userPkId,
  projectPkId,
  entityPkId,
} from '../columnTypes';

export const contentReportSchema: Schema = {
  name: 'contentReport',
  type: 'table',
  version: '1.0.0',
  pkid: 'contentReportPkId',
  columns: {
    contentReportPkId: { ...pkid, name: 'contentReportPkId' },
    enabled,
    createdDate,
    modifiedDate,
    userPkId,
    projectPkId,
    entityPkId,
    entityType: {
      type: 'string',
      typename: 'string',
      minLength: 7,
      maxLength: 50,
      values: ['project', 'codingSession', 'codingSessionContent', 'codingSessionAttachment', 'comment'],
      name: 'entityType',
      required: true,
    },
    message: {
      ...mediumMessage,
      required: true,
    },
    status: {
      type: 'string',
      typename: 'string',
      minLength: 4,
      maxLength: 25,
      values: ['submitted', 'investigation', 'dismissed', 'resolved', 'retracted'],
      name: 'status',
    },
  },
};

Version 4 (latest)

'use strict';

import { Schema } from '../types';
import {
  pkid,
  enabled,
  createdDate,
  modifiedDate,
  mediumMessage,
  userPkId,
  projectPkId,
  entityPkId,
} from '../columnTypes';

export const contentReportSchema: Schema = {
  name: 'contentReport',
  type: 'table',
  version: '1.0.0',
  pkid: 'contentReportPkId',
  columns: {
    contentReportPkId: { ...pkid, name: 'contentReportPkId' },
    enabled,
    createdDate,
    modifiedDate,
    userPkId,
    projectPkId,
    entityPkId,
    entityType: {
      type: 'string',
      typename: 'string',
      minLength: 7,
      maxLength: 50,
      values: ['project', 'codingSession', 'codingSessionContent', 'codingSessionAttachment', 'comment'],
      name: 'entityType',
      required: true,
    },
    message: {
      ...mediumMessage,
      required: true,
    },
    status: {
      type: 'string',
      typename: 'string',
      minLength: 4,
      maxLength: 25,
      values: ['submitted', 'investigation', 'dismissed', 'resolved', 'retracted'],
      name: 'status',
    },
  },
};

packages/cwc-schema/src/tables/emailVerify.ts

3 versions

Version 1

'use strict';

import { Schema } from '../types.js';
import {
  pkid,
  enabled,
  createdDate,
  modifiedDate,
  confirmationCode,
  email,
  deviceId,
  emailVerificationId,
} from '../columnTypes.js';

export const emailVerifySchema: Schema = {
  name: 'emailVerify',
  type: 'table',
  version: '1.0.0',
  pkid: 'emailVerifyPkId',
  columns: {
    emailVerifyPkId: { ...pkid, name: 'emailVerifyPkId' },
    enabled,
    createdDate,
    modifiedDate,
    confirmationCode,
    email,
    deviceId,
    confirmed: {
      type: 'boolean',
      name: 'confirmed',
      typename: 'confirmed',
    },
    emailVerificationId,
  },
};

Version 2

'use strict';

import { Schema } from '../types';
import {
  pkid,
  enabled,
  createdDate,
  modifiedDate,
  confirmationCode,
  email,
  deviceId,
  emailVerificationId,
} from '../columnTypes';

export const emailVerifySchema: Schema = {
  name: 'emailVerify',
  type: 'table',
  version: '1.0.0',
  pkid: 'emailVerifyPkId',
  columns: {
    emailVerifyPkId: { ...pkid, name: 'emailVerifyPkId' },
    enabled,
    createdDate,
    modifiedDate,
    confirmationCode,
    email,
    deviceId,
    confirmed: {
      type: 'boolean',
      name: 'confirmed',
      typename: 'confirmed',
    },
    emailVerificationId,
  },
};

Version 3 (latest)

'use strict';

import { Schema } from '../types';
import {
  pkid,
  enabled,
  createdDate,
  modifiedDate,
  confirmationCode,
  email,
  deviceId,
  emailVerificationId,
} from '../columnTypes';

export const emailVerifySchema: Schema = {
  name: 'emailVerify',
  type: 'table',
  version: '1.0.0',
  pkid: 'emailVerifyPkId',
  columns: {
    emailVerifyPkId: { ...pkid, name: 'emailVerifyPkId' },
    enabled,
    createdDate,
    modifiedDate,
    confirmationCode,
    email,
    deviceId,
    confirmed: {
      type: 'boolean',
      name: 'confirmed',
      typename: 'confirmed',
    },
    emailVerificationId,
  },
};

packages/cwc-schema/src/tables/errorLog.ts

4 versions

Version 1

'use strict';

import { Schema } from '../types.js';
import {
  pkid,
  enabled,
  createdDate,
  modifiedDate,
  serviceName,
  codeLocation,
  dismissed,
  shortMessage,
  text,
} from '../columnTypes.js';

export const errorLogSchema: Schema = {
  name: 'errorLog',
  type: 'table',
  version: '1.0.0',
  pkid: 'errorLogPkId',
  columns: {
    errorLogPkId: { ...pkid, name: 'errorLogPkId' },
    enabled,
    createdDate,
    modifiedDate,
    userPkId: {
      ...pkid,
      name: 'userPkId',
      typename: 'foreignKey',
      foreignKey: { table: 'user', column: 'userPkId' },
    },
    projectPkId: {
      ...pkid,
      name: 'projectPkId',
      typename: 'foreignKey',
      foreignKey: { table: 'project', column: 'projectPkId' },
    },
    serviceName: {
      ...serviceName,
      values: ['cwc-auth', 'cwc-api', 'cwc-sql', 'cwc-website'],
      required: true,
    },
    codeLocation: {
      ...codeLocation,
      required: true,
    },
    dismissed: {
      ...dismissed,
      required: true,
    },
    errorType: {
      type: 'string',
      typename: 'string',
      minLength: 4,
      maxLength: 25,
      values: ['error', 'info', 'warn', 'debug'],
      name: 'errorType',
    },
    errorMessage: {
      ...shortMessage,
      name: 'errorMessage',
      required: true,
    },
    error: { ...text, name: 'error' },
    stack: { ...text, name: 'stack' },
    data: { ...text, name: 'data' },
    request: { ...text, name: 'request' },
  },
};

Version 2

'use strict';

import { Schema } from '../types';
import {
  pkid,
  enabled,
  createdDate,
  modifiedDate,
  serviceName,
  codeLocation,
  dismissed,
  shortMessage,
  text,
} from '../columnTypes';

export const errorLogSchema: Schema = {
  name: 'errorLog',
  type: 'table',
  version: '1.0.0',
  pkid: 'errorLogPkId',
  columns: {
    errorLogPkId: { ...pkid, name: 'errorLogPkId' },
    enabled,
    createdDate,
    modifiedDate,
    userPkId: {
      ...pkid,
      name: 'userPkId',
      typename: 'foreignKey',
      foreignKey: { table: 'user', column: 'userPkId' },
    },
    projectPkId: {
      ...pkid,
      name: 'projectPkId',
      typename: 'foreignKey',
      foreignKey: { table: 'project', column: 'projectPkId' },
    },
    serviceName: {
      ...serviceName,
      values: ['cwc-auth', 'cwc-api', 'cwc-sql', 'cwc-website'],
      required: true,
    },
    codeLocation: {
      ...codeLocation,
      required: true,
    },
    dismissed: {
      ...dismissed,
      required: true,
    },
    errorType: {
      type: 'string',
      typename: 'string',
      minLength: 4,
      maxLength: 25,
      values: ['error', 'info', 'warn', 'debug'],
      name: 'errorType',
    },
    errorMessage: {
      ...shortMessage,
      name: 'errorMessage',
      required: true,
    },
    error: { ...text, name: 'error' },
    stack: { ...text, name: 'stack' },
    data: { ...text, name: 'data' },
    request: { ...text, name: 'request' },
  },
};

Version 3

'use strict';

import { Schema } from '../types';
import {
  pkid,
  enabled,
  createdDate,
  modifiedDate,
  serviceName,
  codeLocation,
  dismissed,
  shortMessage,
  text,
  userPkId,
  projectPkId,
} from '../columnTypes';

export const errorLogSchema: Schema = {
  name: 'errorLog',
  type: 'table',
  version: '1.0.0',
  pkid: 'errorLogPkId',
  columns: {
    errorLogPkId: { ...pkid, name: 'errorLogPkId' },
    enabled,
    createdDate,
    modifiedDate,
    userPkId,
    projectPkId,
    serviceName: {
      ...serviceName,
      values: ['cwc-auth', 'cwc-api', 'cwc-sql', 'cwc-website'],
      required: true,
    },
    codeLocation: {
      ...codeLocation,
      required: true,
    },
    dismissed: {
      ...dismissed,
      required: true,
    },
    errorType: {
      type: 'string',
      typename: 'string',
      minLength: 4,
      maxLength: 25,
      values: ['error', 'info', 'warn', 'debug'],
      name: 'errorType',
    },
    errorMessage: {
      ...shortMessage,
      name: 'errorMessage',
      required: true,
    },
    error: { ...text, name: 'error' },
    stack: { ...text, name: 'stack' },
    data: { ...text, name: 'data' },
    request: { ...text, name: 'request' },
  },
};

Version 4 (latest)

'use strict';

import { Schema } from '../types';
import {
  pkid,
  enabled,
  createdDate,
  modifiedDate,
  serviceName,
  codeLocation,
  dismissed,
  shortMessage,
  text,
  userPkId,
  projectPkId,
} from '../columnTypes';

export const errorLogSchema: Schema = {
  name: 'errorLog',
  type: 'table',
  version: '1.0.0',
  pkid: 'errorLogPkId',
  columns: {
    errorLogPkId: { ...pkid, name: 'errorLogPkId' },
    enabled,
    createdDate,
    modifiedDate,
    userPkId,
    projectPkId,
    serviceName: {
      ...serviceName,
      values: ['cwc-auth', 'cwc-api', 'cwc-sql', 'cwc-website'],
      required: true,
    },
    codeLocation: {
      ...codeLocation,
      required: true,
    },
    dismissed: {
      ...dismissed,
      required: true,
    },
    errorType: {
      type: 'string',
      typename: 'string',
      minLength: 4,
      maxLength: 25,
      values: ['error', 'info', 'warn', 'debug'],
      name: 'errorType',
    },
    errorMessage: {
      ...shortMessage,
      name: 'errorMessage',
      required: true,
    },
    error: { ...text, name: 'error' },
    stack: { ...text, name: 'stack' },
    data: { ...text, name: 'data' },
    request: { ...text, name: 'request' },
  },
};

packages/cwc-schema/src/tables/featureFlag.ts

3 versions

Version 1

'use strict';

import { Schema } from '../types.js';
import {
  pkid,
  enabled,
  createdDate,
  modifiedDate,
  featureFlagId,
  serviceName,
  description,
} from '../columnTypes.js';

export const featureFlagSchema: Schema = {
  name: 'featureFlag',
  type: 'table',
  version: '1.0.0',
  pkid: 'featureFlagPkId',
  columns: {
    featureFlagPkId: { ...pkid, name: 'featureFlagPkId' },
    enabled,
    createdDate,
    modifiedDate,
    featureFlagType: {
      type: 'string',
      typename: 'string',
      minLength: 6,
      maxLength: 25,
      values: ['feature', 'system'],
      name: 'featureFlagType',
      required: true,
    },
    featureFlagId: {
      ...featureFlagId,
      required: true,
    },
    valueType: {
      type: 'string',
      typename: 'string',
      minLength: 6,
      maxLength: 25,
      values: ['boolean', 'number', 'string', 'object'],
      name: 'valueType',
      required: true,
    },
    value: {
      type: 'string',
      typename: 'string',
      minLength: 1,
      maxLength: 200,
      name: 'value',
      required: true,
    },
    description,
    platform: {
      type: 'string',
      typename: 'string',
      minLength: 3,
      maxLength: 25,
      values: ['all', 'web', 'android', 'ios', 'mobile'],
      name: 'platform',
    },
    serviceName: {
      ...serviceName,
      values: [
        'all',
        'frontend',
        'backend',
        'cwc-app',
        'cwc-sql',
        'cwc-auth',
        'cwc-api',
        'cwc-admin-api',
        'cwc-dashboard',
      ],
      required: true,
    },
  },
};

Version 2

'use strict';

import { Schema } from '../types';
import {
  pkid,
  enabled,
  createdDate,
  modifiedDate,
  featureFlagId,
  serviceName,
  description,
} from '../columnTypes';

export const featureFlagSchema: Schema = {
  name: 'featureFlag',
  type: 'table',
  version: '1.0.0',
  pkid: 'featureFlagPkId',
  columns: {
    featureFlagPkId: { ...pkid, name: 'featureFlagPkId' },
    enabled,
    createdDate,
    modifiedDate,
    featureFlagType: {
      type: 'string',
      typename: 'string',
      minLength: 6,
      maxLength: 25,
      values: ['feature', 'system'],
      name: 'featureFlagType',
      required: true,
    },
    featureFlagId: {
      ...featureFlagId,
      required: true,
    },
    valueType: {
      type: 'string',
      typename: 'string',
      minLength: 6,
      maxLength: 25,
      values: ['boolean', 'number', 'string', 'object'],
      name: 'valueType',
      required: true,
    },
    value: {
      type: 'string',
      typename: 'string',
      minLength: 1,
      maxLength: 200,
      name: 'value',
      required: true,
    },
    description,
    platform: {
      type: 'string',
      typename: 'string',
      minLength: 3,
      maxLength: 25,
      values: ['all', 'web', 'android', 'ios', 'mobile'],
      name: 'platform',
    },
    serviceName: {
      ...serviceName,
      values: [
        'all',
        'frontend',
        'backend',
        'cwc-app',
        'cwc-sql',
        'cwc-auth',
        'cwc-api',
        'cwc-admin-api',
        'cwc-dashboard',
      ],
      required: true,
    },
  },
};

Version 3 (latest)

'use strict';

import { Schema } from '../types';
import {
  pkid,
  enabled,
  createdDate,
  modifiedDate,
  featureFlagId,
  serviceName,
  description,
} from '../columnTypes';

export const featureFlagSchema: Schema = {
  name: 'featureFlag',
  type: 'table',
  version: '1.0.0',
  pkid: 'featureFlagPkId',
  columns: {
    featureFlagPkId: { ...pkid, name: 'featureFlagPkId' },
    enabled,
    createdDate,
    modifiedDate,
    featureFlagType: {
      type: 'string',
      typename: 'string',
      minLength: 6,
      maxLength: 25,
      values: ['feature', 'system'],
      name: 'featureFlagType',
      required: true,
    },
    featureFlagId: {
      ...featureFlagId,
      required: true,
    },
    valueType: {
      type: 'string',
      typename: 'string',
      minLength: 6,
      maxLength: 25,
      values: ['boolean', 'number', 'string', 'object'],
      name: 'valueType',
      required: true,
    },
    value: {
      type: 'string',
      typename: 'string',
      minLength: 1,
      maxLength: 200,
      name: 'value',
      required: true,
    },
    description,
    platform: {
      type: 'string',
      typename: 'string',
      minLength: 3,
      maxLength: 25,
      values: ['all', 'web', 'android', 'ios', 'mobile'],
      name: 'platform',
    },
    serviceName: {
      ...serviceName,
      values: [
        'all',
        'frontend',
        'backend',
        'cwc-app',
        'cwc-sql',
        'cwc-auth',
        'cwc-api',
        'cwc-admin-api',
        'cwc-dashboard',
      ],
      required: true,
    },
  },
};

packages/cwc-schema/src/tables/passwordResetInfo.ts

5 versions

Version 1

'use strict';

import { Schema } from '../types.js';
import {
  pkid,
  enabled,
  createdDate,
  modifiedDate,
  username,
  password,
  email,
  emailVerificationId,
  emailConfirmed,
  deviceId,
  attemptCount,
} from '../columnTypes.js';

export const passwordResetInfoSchema: Schema = {
  name: 'passwordResetInfo',
  type: 'table',
  version: '1.0.0',
  pkid: 'passwordResetInfoPkId',
  columns: {
    passwordResetInfoPkId: { ...pkid, name: 'passwordResetInfoPkId' },
    enabled,
    createdDate,
    modifiedDate,
    userPkId: {
      ...pkid,
      name: 'userPkId',
      typename: 'foreignKey',
      foreignKey: { table: 'user', column: 'userPkId' },
    },
    username,
    password,
    email,
    emailVerificationId,
    emailConfirmed,
    deviceId,
    passwordResetAttempts: { ...attemptCount, name: 'passwordResetAttempts' },
  },
};

Version 2

'use strict';

import { Schema } from '../types';
import {
  pkid,
  enabled,
  createdDate,
  modifiedDate,
  username,
  password,
  email,
  emailVerificationId,
  emailConfirmed,
  deviceId,
  attemptCount,
} from '../columnTypes';

export const passwordResetInfoSchema: Schema = {
  name: 'passwordResetInfo',
  type: 'table',
  version: '1.0.0',
  pkid: 'passwordResetInfoPkId',
  columns: {
    passwordResetInfoPkId: { ...pkid, name: 'passwordResetInfoPkId' },
    enabled,
    createdDate,
    modifiedDate,
    userPkId: {
      ...pkid,
      name: 'userPkId',
      typename: 'foreignKey',
      foreignKey: { table: 'user', column: 'userPkId' },
    },
    username,
    password,
    email,
    emailVerificationId,
    emailConfirmed,
    deviceId,
    passwordResetAttempts: { ...attemptCount, name: 'passwordResetAttempts' },
  },
};

Version 3

'use strict';

import { Schema } from '../types';
import {
  pkid,
  enabled,
  createdDate,
  modifiedDate,
  username,
  password,
  email,
  emailVerificationId,
  emailConfirmed,
  deviceId,
  attemptCount,
  userPkId,
} from '../columnTypes';

export const passwordResetInfoSchema: Schema = {
  name: 'passwordResetInfo',
  type: 'table',
  version: '1.0.0',
  pkid: 'passwordResetInfoPkId',
  columns: {
    passwordResetInfoPkId: { ...pkid, name: 'passwordResetInfoPkId' },
    enabled,
    createdDate,
    modifiedDate,
    userPkId,
    username,
    password,
    email,
    emailVerificationId,
    emailConfirmed,
    deviceId,
    passwordResetAttempts: { ...attemptCount, name: 'passwordResetAttempts' },
  },
};

Version 4

'use strict';

import { Schema } from '../types';
import {
  pkid,
  enabled,
  createdDate,
  modifiedDate,
  username,
  password,
  email,
  emailVerificationId,
  emailConfirmed,
  deviceId,
  attemptCount,
  userPkId,
} from '../columnTypes';
import { passwordStrengthValidator } from '../validation/zodValidators';

export const passwordResetInfoSchema: Schema = {
  name: 'passwordResetInfo',
  type: 'table',
  version: '1.0.0',
  pkid: 'passwordResetInfoPkId',
  columns: {
    passwordResetInfoPkId: { ...pkid, name: 'passwordResetInfoPkId' },
    enabled,
    createdDate,
    modifiedDate,
    userPkId,
    username,
    password: {
      ...password,
      zodValidator: passwordStrengthValidator,
    },
    email,
    emailVerificationId,
    emailConfirmed,
    deviceId,
    passwordResetAttempts: { ...attemptCount, name: 'passwordResetAttempts' },
  },
};

Version 5 (latest)

'use strict';

import { Schema } from '../types';
import {
  pkid,
  enabled,
  createdDate,
  modifiedDate,
  username,
  password,
  email,
  emailVerificationId,
  emailConfirmed,
  deviceId,
  attemptCount,
  userPkId,
} from '../columnTypes';
import { passwordStrengthValidator } from '../validation/zodValidators';

export const passwordResetInfoSchema: Schema = {
  name: 'passwordResetInfo',
  type: 'table',
  version: '1.0.0',
  pkid: 'passwordResetInfoPkId',
  columns: {
    passwordResetInfoPkId: { ...pkid, name: 'passwordResetInfoPkId' },
    enabled,
    createdDate,
    modifiedDate,
    userPkId,
    username,
    password: {
      ...password,
      zodValidator: passwordStrengthValidator,
    },
    email,
    emailVerificationId,
    emailConfirmed,
    deviceId,
    passwordResetAttempts: { ...attemptCount, name: 'passwordResetAttempts' },
  },
};

packages/cwc-schema/src/tables/project.ts

4 versions

Version 1

'use strict';

import { Schema } from '../types.js';
import { pkid, enabled, createdDate, modifiedDate, projectId } from '../columnTypes.js';

export const projectSchema: Schema = {
  name: 'project',
  type: 'table',
  version: '1.0.0',
  pkid: 'projectPkId',
  columns: {
    projectPkId: { ...pkid, name: 'projectPkId' },
    enabled,
    createdDate,
    modifiedDate,
    projectId,
    projectType: {
      type: 'string',
      typename: 'string',
      minLength: 2,
      maxLength: 25,
      values: ['web', 'mobile', 'backend', 'ai'],
      name: 'projectType',
    },
    userPkId: {
      ...pkid,
      name: 'userPkId',
      typename: 'foreignKey',
      foreignKey: { table: 'user', column: 'userPkId' },
    },
  },
};

Version 2

'use strict';

import { Schema } from '../types';
import { pkid, enabled, createdDate, modifiedDate, projectId } from '../columnTypes';

export const projectSchema: Schema = {
  name: 'project',
  type: 'table',
  version: '1.0.0',
  pkid: 'projectPkId',
  columns: {
    projectPkId: { ...pkid, name: 'projectPkId' },
    enabled,
    createdDate,
    modifiedDate,
    projectId,
    projectType: {
      type: 'string',
      typename: 'string',
      minLength: 2,
      maxLength: 25,
      values: ['web', 'mobile', 'backend', 'ai'],
      name: 'projectType',
    },
    userPkId: {
      ...pkid,
      name: 'userPkId',
      typename: 'foreignKey',
      foreignKey: { table: 'user', column: 'userPkId' },
    },
  },
};

Version 3

'use strict';

import { Schema } from '../types';
import { pkid, enabled, createdDate, modifiedDate, projectId, userPkId } from '../columnTypes';

export const projectSchema: Schema = {
  name: 'project',
  type: 'table',
  version: '1.0.0',
  pkid: 'projectPkId',
  columns: {
    projectPkId: { ...pkid, name: 'projectPkId' },
    enabled,
    createdDate,
    modifiedDate,
    projectId,
    projectType: {
      type: 'string',
      typename: 'string',
      minLength: 2,
      maxLength: 25,
      values: ['web', 'mobile', 'backend', 'ai'],
      name: 'projectType',
    },
    userPkId,
  },
};

Version 4 (latest)

'use strict';

import { Schema } from '../types';
import { pkid, enabled, createdDate, modifiedDate, projectId, userPkId } from '../columnTypes';

export const projectSchema: Schema = {
  name: 'project',
  type: 'table',
  version: '1.0.0',
  pkid: 'projectPkId',
  columns: {
    projectPkId: { ...pkid, name: 'projectPkId' },
    enabled,
    createdDate,
    modifiedDate,
    projectId,
    projectType: {
      type: 'string',
      typename: 'string',
      minLength: 2,
      maxLength: 25,
      values: ['web', 'mobile', 'backend', 'ai'],
      name: 'projectType',
    },
    userPkId,
  },
};

packages/cwc-schema/src/tables/reaction.ts

4 versions

Version 1

'use strict';

import { Schema } from '../types.js';
import { pkid, enabled, createdDate, modifiedDate, reactionName } from '../columnTypes.js';

export const reactionSchema: Schema = {
  name: 'reaction',
  type: 'table',
  version: '1.0.0',
  pkid: 'reactionPkId',
  columns: {
    reactionPkId: { ...pkid, name: 'reactionPkId' },
    enabled,
    createdDate,
    modifiedDate,
    projectPkId: {
      ...pkid,
      name: 'projectPkId',
      typename: 'foreignKey',
      foreignKey: { table: 'project', column: 'projectPkId' },
    },
    userPkId: {
      ...pkid,
      name: 'userPkId',
      typename: 'foreignKey',
      foreignKey: { table: 'user', column: 'userPkId' },
    },
    entityPkId: {
      ...pkid,
      name: 'entityPkId',
      typename: 'foreignKey',
      required: true,
    },
    entityType: {
      type: 'string',
      typename: 'string',
      minLength: 7,
      maxLength: 50,
      values: ['project', 'codingSession', 'codingSessionContent', 'codingSessionAttachment', 'comment'],
      name: 'entityType',
      required: true,
    },
    reactionName: {
      ...reactionName,
      values: ['love', 'funny', 'sad', 'wow', 'thumbs-up'],
    },
  },
};

Version 2

'use strict';

import { Schema } from '../types';
import { pkid, enabled, createdDate, modifiedDate, reactionName } from '../columnTypes';

export const reactionSchema: Schema = {
  name: 'reaction',
  type: 'table',
  version: '1.0.0',
  pkid: 'reactionPkId',
  columns: {
    reactionPkId: { ...pkid, name: 'reactionPkId' },
    enabled,
    createdDate,
    modifiedDate,
    projectPkId: {
      ...pkid,
      name: 'projectPkId',
      typename: 'foreignKey',
      foreignKey: { table: 'project', column: 'projectPkId' },
    },
    userPkId: {
      ...pkid,
      name: 'userPkId',
      typename: 'foreignKey',
      foreignKey: { table: 'user', column: 'userPkId' },
    },
    entityPkId: {
      ...pkid,
      name: 'entityPkId',
      typename: 'foreignKey',
      required: true,
    },
    entityType: {
      type: 'string',
      typename: 'string',
      minLength: 7,
      maxLength: 50,
      values: ['project', 'codingSession', 'codingSessionContent', 'codingSessionAttachment', 'comment'],
      name: 'entityType',
      required: true,
    },
    reactionName: {
      ...reactionName,
      values: ['love', 'funny', 'sad', 'wow', 'thumbs-up'],
    },
  },
};

Version 3

'use strict';

import { Schema } from '../types';
import {
  pkid,
  enabled,
  createdDate,
  modifiedDate,
  reactionName,
  userPkId,
  projectPkId,
  entityPkId,
} from '../columnTypes';

export const reactionSchema: Schema = {
  name: 'reaction',
  type: 'table',
  version: '1.0.0',
  pkid: 'reactionPkId',
  columns: {
    reactionPkId: { ...pkid, name: 'reactionPkId' },
    enabled,
    createdDate,
    modifiedDate,
    projectPkId,
    userPkId,
    entityPkId,
    entityType: {
      type: 'string',
      typename: 'string',
      minLength: 7,
      maxLength: 50,
      values: ['project', 'codingSession', 'codingSessionContent', 'codingSessionAttachment', 'comment'],
      name: 'entityType',
      required: true,
    },
    reactionName: {
      ...reactionName,
      values: ['love', 'funny', 'sad', 'wow', 'thumbs-up'],
    },
  },
};

Version 4 (latest)

'use strict';

import { Schema } from '../types';
import {
  pkid,
  enabled,
  createdDate,
  modifiedDate,
  reactionName,
  userPkId,
  projectPkId,
  entityPkId,
} from '../columnTypes';

export const reactionSchema: Schema = {
  name: 'reaction',
  type: 'table',
  version: '1.0.0',
  pkid: 'reactionPkId',
  columns: {
    reactionPkId: { ...pkid, name: 'reactionPkId' },
    enabled,
    createdDate,
    modifiedDate,
    projectPkId,
    userPkId,
    entityPkId,
    entityType: {
      type: 'string',
      typename: 'string',
      minLength: 7,
      maxLength: 50,
      values: ['project', 'codingSession', 'codingSessionContent', 'codingSessionAttachment', 'comment'],
      name: 'entityType',
      required: true,
    },
    reactionName: {
      ...reactionName,
      values: ['love', 'funny', 'sad', 'wow', 'thumbs-up'],
    },
  },
};

packages/cwc-schema/src/tables/signupInfo.ts

5 versions

Version 1

'use strict';

import { Schema } from '../types.js';
import {
  pkid,
  enabled,
  createdDate,
  modifiedDate,
  username,
  password,
  email,
  emailVerificationId,
  emailConfirmed,
  deviceId,
  attemptCount,
} from '../columnTypes.js';

export const signupInfoSchema: Schema = {
  name: 'signupInfo',
  type: 'table',
  version: '1.0.0',
  pkid: 'signupInfoPkId',
  columns: {
    signupInfoPkId: { ...pkid, name: 'signupInfoPkId' },
    enabled,
    createdDate,
    modifiedDate,
    loginType: {
      type: 'string',
      typename: 'string',
      minLength: 3,
      maxLength: 25,
      values: ['cwc', 'facebook', 'google'],
      name: 'loginType',
    },
    userPkId: {
      ...pkid,
      name: 'userPkId',
      typename: 'foreignKey',
      foreignKey: { table: 'user', column: 'userPkId' },
    },
    username,
    password,
    email,
    emailVerificationId,
    emailConfirmed,
    deviceId,
    signupAttempts: { ...attemptCount, name: 'signupAttempts' },
  },
};

Version 2

'use strict';

import { Schema } from '../types';
import {
  pkid,
  enabled,
  createdDate,
  modifiedDate,
  username,
  password,
  email,
  emailVerificationId,
  emailConfirmed,
  deviceId,
  attemptCount,
} from '../columnTypes';

export const signupInfoSchema: Schema = {
  name: 'signupInfo',
  type: 'table',
  version: '1.0.0',
  pkid: 'signupInfoPkId',
  columns: {
    signupInfoPkId: { ...pkid, name: 'signupInfoPkId' },
    enabled,
    createdDate,
    modifiedDate,
    loginType: {
      type: 'string',
      typename: 'string',
      minLength: 3,
      maxLength: 25,
      values: ['cwc', 'facebook', 'google'],
      name: 'loginType',
    },
    userPkId: {
      ...pkid,
      name: 'userPkId',
      typename: 'foreignKey',
      foreignKey: { table: 'user', column: 'userPkId' },
    },
    username,
    password,
    email,
    emailVerificationId,
    emailConfirmed,
    deviceId,
    signupAttempts: { ...attemptCount, name: 'signupAttempts' },
  },
};

Version 3

'use strict';

import { Schema } from '../types';
import {
  pkid,
  enabled,
  createdDate,
  modifiedDate,
  username,
  password,
  email,
  emailVerificationId,
  emailConfirmed,
  deviceId,
  attemptCount,
  userPkId,
  loginType,
} from '../columnTypes';

export const signupInfoSchema: Schema = {
  name: 'signupInfo',
  type: 'table',
  version: '1.0.0',
  pkid: 'signupInfoPkId',
  columns: {
    signupInfoPkId: { ...pkid, name: 'signupInfoPkId' },
    enabled,
    createdDate,
    modifiedDate,
    loginType,
    userPkId,
    username,
    password,
    email,
    emailVerificationId,
    emailConfirmed,
    deviceId,
    signupAttempts: { ...attemptCount, name: 'signupAttempts' },
  },
};

Version 4

'use strict';

import { Schema } from '../types';
import {
  pkid,
  enabled,
  createdDate,
  modifiedDate,
  username,
  password,
  email,
  emailVerificationId,
  emailConfirmed,
  deviceId,
  attemptCount,
  userPkId,
  loginType,
} from '../columnTypes';
import { passwordStrengthValidator } from '../validation/zodValidators';

export const signupInfoSchema: Schema = {
  name: 'signupInfo',
  type: 'table',
  version: '1.0.0',
  pkid: 'signupInfoPkId',
  columns: {
    signupInfoPkId: { ...pkid, name: 'signupInfoPkId' },
    enabled,
    createdDate,
    modifiedDate,
    loginType,
    userPkId,
    username,
    password: {
      ...password,
      zodValidator: passwordStrengthValidator,
    },
    email,
    emailVerificationId,
    emailConfirmed,
    deviceId,
    signupAttempts: { ...attemptCount, name: 'signupAttempts' },
  },
};

Version 5 (latest)

'use strict';

import { Schema } from '../types';
import {
  pkid,
  enabled,
  createdDate,
  modifiedDate,
  username,
  password,
  email,
  emailVerificationId,
  emailConfirmed,
  deviceId,
  attemptCount,
  userPkId,
  loginType,
} from '../columnTypes';
import { passwordStrengthValidator } from '../validation/zodValidators';

export const signupInfoSchema: Schema = {
  name: 'signupInfo',
  type: 'table',
  version: '1.0.0',
  pkid: 'signupInfoPkId',
  columns: {
    signupInfoPkId: { ...pkid, name: 'signupInfoPkId' },
    enabled,
    createdDate,
    modifiedDate,
    loginType,
    userPkId,
    username,
    password: {
      ...password,
      zodValidator: passwordStrengthValidator,
    },
    email,
    emailVerificationId,
    emailConfirmed,
    deviceId,
    signupAttempts: { ...attemptCount, name: 'signupAttempts' },
  },
};

packages/cwc-schema/src/tables/tempJwt.ts

3 versions

Version 1

'use strict';

import { Schema } from '../types.js';
import { pkid, enabled, createdDate, modifiedDate, uuid } from '../columnTypes.js';

export const tempJwtSchema: Schema = {
  name: 'tempJwt',
  type: 'table',
  version: '1.0.0',
  pkid: 'tempJwtPkId',
  columns: {
    tempJwtPkId: { ...pkid, name: 'tempJwtPkId' },
    enabled,
    createdDate,
    modifiedDate,
    tempJwtId: { ...uuid, name: 'tempJwtId' },
  },
};

Version 2

'use strict';

import { Schema } from '../types';
import { pkid, enabled, createdDate, modifiedDate, uuid } from '../columnTypes';

export const tempJwtSchema: Schema = {
  name: 'tempJwt',
  type: 'table',
  version: '1.0.0',
  pkid: 'tempJwtPkId',
  columns: {
    tempJwtPkId: { ...pkid, name: 'tempJwtPkId' },
    enabled,
    createdDate,
    modifiedDate,
    tempJwtId: { ...uuid, name: 'tempJwtId' },
  },
};

Version 3 (latest)

'use strict';

import { Schema } from '../types';
import { pkid, enabled, createdDate, modifiedDate, uuid } from '../columnTypes';

export const tempJwtSchema: Schema = {
  name: 'tempJwt',
  type: 'table',
  version: '1.0.0',
  pkid: 'tempJwtPkId',
  columns: {
    tempJwtPkId: { ...pkid, name: 'tempJwtPkId' },
    enabled,
    createdDate,
    modifiedDate,
    tempJwtId: { ...uuid, name: 'tempJwtId' },
  },
};

packages/cwc-schema/src/tables/user.ts

4 versions

Version 1

'use strict';

import { Schema } from '../types.js';
import {
  pkid,
  enabled,
  createdDate,
  modifiedDate,
  username,
  loginDate,
  password,
  email,
  emailConfirmed,
  deviceId,
  otpSecret,
  otpValidated,
} from '../columnTypes.js';

export const userSchema: Schema = {
  name: 'user',
  type: 'table',
  version: '1.0.0',
  pkid: 'userPkId',
  columns: {
    userPkId: { ...pkid, name: 'userPkId' },
    enabled,
    createdDate,
    modifiedDate,
    username,
    loginType: {
      type: 'string',
      typename: 'string',
      minLength: 3,
      maxLength: 25,
      values: ['cwc', 'facebook', 'google'],
      name: 'loginType',
    },
    loginDate,
    password,
    email,
    emailConfirmed,
    deviceId,
    otpSecret,
    otpValidated,
  },
};

Version 2

'use strict';

import { Schema } from '../types';
import {
  pkid,
  enabled,
  createdDate,
  modifiedDate,
  username,
  loginDate,
  password,
  email,
  emailConfirmed,
  deviceId,
  otpSecret,
  otpValidated,
} from '../columnTypes';

export const userSchema: Schema = {
  name: 'user',
  type: 'table',
  version: '1.0.0',
  pkid: 'userPkId',
  columns: {
    userPkId: { ...pkid, name: 'userPkId' },
    enabled,
    createdDate,
    modifiedDate,
    username,
    loginType: {
      type: 'string',
      typename: 'string',
      minLength: 3,
      maxLength: 25,
      values: ['cwc', 'facebook', 'google'],
      name: 'loginType',
    },
    loginDate,
    password,
    email,
    emailConfirmed,
    deviceId,
    otpSecret,
    otpValidated,
  },
};

Version 3

'use strict';

import { Schema } from '../types';
import {
  pkid,
  enabled,
  createdDate,
  modifiedDate,
  username,
  loginDate,
  password,
  email,
  emailConfirmed,
  deviceId,
  otpSecret,
  otpValidated,
  loginType,
} from '../columnTypes';

export const userSchema: Schema = {
  name: 'user',
  type: 'table',
  version: '1.0.0',
  pkid: 'userPkId',
  columns: {
    userPkId: { ...pkid, name: 'userPkId' },
    enabled,
    createdDate,
    modifiedDate,
    username,
    loginType,
    loginDate,
    password,
    email,
    emailConfirmed,
    deviceId,
    otpSecret,
    otpValidated,
  },
};

Version 4 (latest)

'use strict';

import { Schema } from '../types';
import {
  pkid,
  enabled,
  createdDate,
  modifiedDate,
  username,
  loginDate,
  password,
  email,
  emailConfirmed,
  deviceId,
  otpSecret,
  otpValidated,
  loginType,
} from '../columnTypes';

export const userSchema: Schema = {
  name: 'user',
  type: 'table',
  version: '1.0.0',
  pkid: 'userPkId',
  columns: {
    userPkId: { ...pkid, name: 'userPkId' },
    enabled,
    createdDate,
    modifiedDate,
    username,
    loginType,
    loginDate,
    password,
    email,
    emailConfirmed,
    deviceId,
    otpSecret,
    otpValidated,
  },
};

packages/cwc-schema/src/tables/userJwt.ts

3 versions

Version 1

'use strict';

import { Schema } from '../types.js';
import { pkid, enabled, createdDate, modifiedDate, uuid } from '../columnTypes.js';

export const userJwtSchema: Schema = {
  name: 'userJwt',
  type: 'table',
  version: '1.0.0',
  pkid: 'userJwtPkId',
  columns: {
    userJwtPkId: { ...pkid, name: 'userJwtPkId' },
    enabled,
    createdDate,
    modifiedDate,
    userJwtId: { ...uuid, name: 'userJwtId' },
  },
};

Version 2

'use strict';

import { Schema } from '../types';
import { pkid, enabled, createdDate, modifiedDate, uuid } from '../columnTypes';

export const userJwtSchema: Schema = {
  name: 'userJwt',
  type: 'table',
  version: '1.0.0',
  pkid: 'userJwtPkId',
  columns: {
    userJwtPkId: { ...pkid, name: 'userJwtPkId' },
    enabled,
    createdDate,
    modifiedDate,
    userJwtId: { ...uuid, name: 'userJwtId' },
  },
};

Version 3 (latest)

'use strict';

import { Schema } from '../types';
import { pkid, enabled, createdDate, modifiedDate, uuid } from '../columnTypes';

export const userJwtSchema: Schema = {
  name: 'userJwt',
  type: 'table',
  version: '1.0.0',
  pkid: 'userJwtPkId',
  columns: {
    userJwtPkId: { ...pkid, name: 'userJwtPkId' },
    enabled,
    createdDate,
    modifiedDate,
    userJwtId: { ...uuid, name: 'userJwtId' },
  },
};

packages/cwc-schema/src/types.ts

3 versions

Version 1

'use strict';

export type SchemaColumn = {
  /** Primitive JavaScript/SQL type */
  type: 'string' | 'number' | 'boolean' | 'object';

  /** Actual column name in database table */
  name: string;

  /** Semantic type category (e.g., 'uuid', 'email', 'phone') for validation/documentation */
  typename: string;

  /** Whether this column is required (true) or optional (false/undefined) */
  required?: boolean;

  // String validation
  minLength?: number;
  maxLength?: number;
  regex?: RegExp;
  /** Allowed enum values for this column */
  values?: string[];

  // Number validation
  minValue?: number;
  /** Maximum value. If undefined, no maximum limit */
  maxValue?: number;

  /** Foreign key relationship metadata */
  foreignKey?: {
    table: string;
    column: string;
    onDelete?: 'CASCADE' | 'SET NULL' | 'RESTRICT';
  };
};

export type Schema = {
  /** Table or view name */
  name: string;

  /** Schema type */
  type: 'table' | 'view';

  /** Schema version for migration tracking (optional) */
  version?: string;

  /** Primary key column name (undefined for views) */
  pkid: string | undefined;

  /** Column definitions */
  columns: Record<string, SchemaColumn>;
};

Version 2

'use strict';

import { z } from 'zod';

export type SchemaColumn = {
  /** Primitive JavaScript/SQL type */
  type: 'string' | 'number' | 'boolean' | 'object';

  /** Actual column name in database table */
  name: string;

  /** Semantic type category (e.g., 'uuid', 'email', 'phone') for validation/documentation */
  typename: string;

  /** Whether this column is required (true) or optional (false/undefined) */
  required?: boolean;

  // String validation
  minLength?: number;
  maxLength?: number;
  regex?: RegExp;
  /** Allowed enum values for this column */
  values?: string[];

  // Number validation
  minValue?: number;
  /** Maximum value. If undefined, no maximum limit */
  maxValue?: number;

  /** Foreign key relationship metadata */
  foreignKey?: {
    table: string;
    column: string;
    onDelete?: 'CASCADE' | 'SET NULL' | 'RESTRICT';
  };

  /**
   * Optional Zod validator for complex validation logic.
   * When present, Zod validation is used instead of custom validation.
   * Allows opt-in to Zod for complex cases while maintaining custom validation as default.
   */
  zodValidator?: z.ZodType<unknown>;
};

export type Schema = {
  /** Table or view name */
  name: string;

  /** Schema type */
  type: 'table' | 'view';

  /** Schema version for migration tracking (optional) */
  version?: string;

  /** Primary key column name (undefined for views) */
  pkid: string | undefined;

  /** Column definitions */
  columns: Record<string, SchemaColumn>;
};

Version 3 (latest)

'use strict';

import { z } from 'zod';

export type SchemaColumn = {
  /** Primitive JavaScript/SQL type */
  type: 'string' | 'number' | 'boolean' | 'object';

  /** Actual column name in database table */
  name: string;

  /** Semantic type category (e.g., 'uuid', 'email', 'phone') for validation/documentation */
  typename: string;

  /** Whether this column is required (true) or optional (false/undefined) */
  required?: boolean;

  // String validation
  minLength?: number;
  maxLength?: number;
  regex?: RegExp;
  /** Allowed enum values for this column */
  values?: string[];

  // Number validation
  minValue?: number;
  /** Maximum value. If undefined, no maximum limit */
  maxValue?: number;

  /** Foreign key relationship metadata */
  foreignKey?: {
    table: string;
    column: string;
    onDelete?: 'CASCADE' | 'SET NULL' | 'RESTRICT';
  };

  /**
   * Optional Zod validator for complex validation logic.
   * When present, Zod validation is used instead of custom validation.
   * Allows opt-in to Zod for complex cases while maintaining custom validation as default.
   */
  zodValidator?: z.ZodType<unknown>;
};

export type Schema = {
  /** Table or view name */
  name: string;

  /** Schema type */
  type: 'table' | 'view';

  /** Schema version for migration tracking (optional) */
  version?: string;

  /** Primary key column name (undefined for views) */
  pkid: string | undefined;

  /** Column definitions */
  columns: Record<string, SchemaColumn>;
};

packages/cwc-schema/src/validation/regexPatterns.ts

2 versions

Version 1

'use strict';

/**
 * Email validation regex
 * Note: Basic validation - may need enhancement for full RFC 5322 compliance
 */
export const EMAIL_REGEX = /^\w+([\.-]?\w+)*@\w+([\.-]?\w+)*(\.\w{2,})+$/;

/**
 * UUID v4 validation (36 characters with hyphens)
 * Used for: deviceId, emailVerificationId, various JWT IDs
 */
export const UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;

/**
 * Username validation
 * Alphanumeric plus underscores, 4-100 characters
 */
export const USERNAME_REGEX = /^[a-zA-Z0-9_]{4,100}$/;

/**
 * Confirmation code validation (6 characters)
 * Used for email verification
 */
export const CONFIRMATION_CODE_REGEX = /^[A-Z0-9]{6}$/;

/**
 * Project ID validation (alphanumeric with hyphens, up to 150 characters)
 * Allows URL-friendly identifiers
 */
export const PROJECT_ID_REGEX = /^[a-zA-Z0-9-]{1,150}$/;

/**
 * Filename validation (up to 50 characters, alphanumeric plus common file chars)
 * Allows letters, numbers, dots, dashes, underscores
 */
export const FILENAME_REGEX = /^[a-zA-Z0-9._-]{1,50}$/;

Version 2 (latest)

'use strict';

/**
 * Email validation regex
 * Note: Basic validation - may need enhancement for full RFC 5322 compliance
 */
export const EMAIL_REGEX = /^\w+([\.-]?\w+)*@\w+([\.-]?\w+)*(\.\w{2,})+$/;

/**
 * UUID v4 validation (36 characters with hyphens)
 * Used for: deviceId, emailVerificationId, various JWT IDs
 */
export const UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;

/**
 * Username validation
 * Alphanumeric plus underscores, 4-100 characters
 */
export const USERNAME_REGEX = /^[a-zA-Z0-9_]{4,100}$/;

/**
 * Confirmation code validation (6 characters)
 * Used for email verification
 */
export const CONFIRMATION_CODE_REGEX = /^[A-Z0-9]{6}$/;

/**
 * Project ID validation (alphanumeric with hyphens, up to 150 characters)
 * Allows URL-friendly identifiers
 */
export const PROJECT_ID_REGEX = /^[a-zA-Z0-9-]{1,150}$/;

/**
 * Filename validation (up to 50 characters, alphanumeric plus common file chars)
 * Allows letters, numbers, dots, dashes, underscores
 */
export const FILENAME_REGEX = /^[a-zA-Z0-9._-]{1,50}$/;

packages/cwc-schema/src/validation/validator.ts

4 versions

Version 1

'use strict';

import { Schema, SchemaColumn } from '../types.js';

export type ValidationError = {
  field: string;
  message: string;
  value?: unknown;
};

export type ValidationResult = {
  valid: boolean;
  errors: ValidationError[];
};

/**
 * Validate a single column value against its schema definition
 */
export const validateColumn = (
  value: unknown,
  column: SchemaColumn,
  fieldName?: string
): ValidationResult => {
  const errors: ValidationError[] = [];
  const field = fieldName || column.name;

  // Check required
  if (column.required && (value === null || value === undefined)) {
    errors.push({
      field,
      message: `Field '${field}' is required`,
      value,
    });
    return { valid: false, errors };
  }

  // If value is null/undefined and not required, skip further validation
  if (value === null || value === undefined) {
    return { valid: true, errors: [] };
  }

  // Type validation
  const actualType = typeof value;
  let expectedType = column.type;
  if (expectedType === 'object') expectedType = 'object';

  if (actualType !== expectedType) {
    errors.push({
      field,
      message: `Field '${field}' must be of type ${column.type}, got ${actualType}`,
      value,
    });
    return { valid: false, errors };
  }

  // String validation
  if (column.type === 'string' && typeof value === 'string') {
    if (column.minLength !== undefined && value.length < column.minLength) {
      errors.push({
        field,
        message: `Field '${field}' must be at least ${column.minLength} characters, got ${value.length}`,
        value,
      });
    }

    if (column.maxLength !== undefined && value.length > column.maxLength) {
      errors.push({
        field,
        message: `Field '${field}' must be at most ${column.maxLength} characters, got ${value.length}`,
        value,
      });
    }

    if (column.regex && !column.regex.test(value)) {
      errors.push({
        field,
        message: `Field '${field}' does not match required format`,
        value,
      });
    }

    if (column.values && !column.values.includes(value)) {
      errors.push({
        field,
        message: `Field '${field}' must be one of: [${column.values.join(', ')}], got '${value}'`,
        value,
      });
    }
  }

  // Number validation
  if (column.type === 'number' && typeof value === 'number') {
    if (column.minValue !== undefined && value < column.minValue) {
      errors.push({
        field,
        message: `Field '${field}' must be at least ${column.minValue}, got ${value}`,
        value,
      });
    }

    if (column.maxValue !== undefined && value > column.maxValue) {
      errors.push({
        field,
        message: `Field '${field}' must be at most ${column.maxValue}, got ${value}`,
        value,
      });
    }
  }

  return {
    valid: errors.length === 0,
    errors,
  };
};

/**
 * Validate an entire entity against its schema
 */
export const validateEntity = (data: Record<string, unknown>, schema: Schema): ValidationResult => {
  const errors: ValidationError[] = [];

  // Validate each column in the schema
  for (const [columnName, columnDef] of Object.entries(schema.columns)) {
    const value = data[columnName];
    const result = validateColumn(value, columnDef, columnName);

    if (!result.valid) {
      errors.push(...result.errors);
    }
  }

  // Check for unexpected fields
  for (const key of Object.keys(data)) {
    if (!schema.columns[key]) {
      errors.push({
        field: key,
        message: `Unexpected field '${key}' not defined in schema '${schema.name}'`,
        value: data[key],
      });
    }
  }

  return {
    valid: errors.length === 0,
    errors,
  };
};

/**
 * Validate a partial entity (useful for updates where not all fields are provided)
 */
export const validatePartialEntity = (
  data: Record<string, unknown>,
  schema: Schema
): ValidationResult => {
  const errors: ValidationError[] = [];

  // Only validate fields that are present in the data
  for (const [columnName, value] of Object.entries(data)) {
    const columnDef = schema.columns[columnName];

    if (!columnDef) {
      errors.push({
        field: columnName,
        message: `Unexpected field '${columnName}' not defined in schema '${schema.name}'`,
        value,
      });
      continue;
    }

    // For partial validation, ignore the 'required' constraint
    const result = validateColumn(value, { ...columnDef, required: false }, columnName);

    if (!result.valid) {
      errors.push(...result.errors);
    }
  }

  return {
    valid: errors.length === 0,
    errors,
  };
};

Version 2

'use strict';

import { Schema, SchemaColumn } from '../types';

export type ValidationError = {
  field: string;
  message: string;
  value?: unknown;
};

export type ValidationResult = {
  valid: boolean;
  errors: ValidationError[];
};

/**
 * Validate a single column value against its schema definition
 */
export const validateColumn = (
  value: unknown,
  column: SchemaColumn,
  fieldName?: string
): ValidationResult => {
  const errors: ValidationError[] = [];
  const field = fieldName || column.name;

  // Check required
  if (column.required && (value === null || value === undefined)) {
    errors.push({
      field,
      message: `Field '${field}' is required`,
      value,
    });
    return { valid: false, errors };
  }

  // If value is null/undefined and not required, skip further validation
  if (value === null || value === undefined) {
    return { valid: true, errors: [] };
  }

  // Type validation
  const actualType = typeof value;
  let expectedType = column.type;
  if (expectedType === 'object') expectedType = 'object';

  if (actualType !== expectedType) {
    errors.push({
      field,
      message: `Field '${field}' must be of type ${column.type}, got ${actualType}`,
      value,
    });
    return { valid: false, errors };
  }

  // String validation
  if (column.type === 'string' && typeof value === 'string') {
    if (column.minLength !== undefined && value.length < column.minLength) {
      errors.push({
        field,
        message: `Field '${field}' must be at least ${column.minLength} characters, got ${value.length}`,
        value,
      });
    }

    if (column.maxLength !== undefined && value.length > column.maxLength) {
      errors.push({
        field,
        message: `Field '${field}' must be at most ${column.maxLength} characters, got ${value.length}`,
        value,
      });
    }

    if (column.regex && !column.regex.test(value)) {
      errors.push({
        field,
        message: `Field '${field}' does not match required format`,
        value,
      });
    }

    if (column.values && !column.values.includes(value)) {
      errors.push({
        field,
        message: `Field '${field}' must be one of: [${column.values.join(', ')}], got '${value}'`,
        value,
      });
    }
  }

  // Number validation
  if (column.type === 'number' && typeof value === 'number') {
    if (column.minValue !== undefined && value < column.minValue) {
      errors.push({
        field,
        message: `Field '${field}' must be at least ${column.minValue}, got ${value}`,
        value,
      });
    }

    if (column.maxValue !== undefined && value > column.maxValue) {
      errors.push({
        field,
        message: `Field '${field}' must be at most ${column.maxValue}, got ${value}`,
        value,
      });
    }
  }

  return {
    valid: errors.length === 0,
    errors,
  };
};

/**
 * Validate an entire entity against its schema
 */
export const validateEntity = (data: Record<string, unknown>, schema: Schema): ValidationResult => {
  const errors: ValidationError[] = [];

  // Validate each column in the schema
  for (const [columnName, columnDef] of Object.entries(schema.columns)) {
    const value = data[columnName];
    const result = validateColumn(value, columnDef, columnName);

    if (!result.valid) {
      errors.push(...result.errors);
    }
  }

  // Check for unexpected fields
  for (const key of Object.keys(data)) {
    if (!schema.columns[key]) {
      errors.push({
        field: key,
        message: `Unexpected field '${key}' not defined in schema '${schema.name}'`,
        value: data[key],
      });
    }
  }

  return {
    valid: errors.length === 0,
    errors,
  };
};

/**
 * Validate a partial entity (useful for updates where not all fields are provided)
 */
export const validatePartialEntity = (
  data: Record<string, unknown>,
  schema: Schema
): ValidationResult => {
  const errors: ValidationError[] = [];

  // Only validate fields that are present in the data
  for (const [columnName, value] of Object.entries(data)) {
    const columnDef = schema.columns[columnName];

    if (!columnDef) {
      errors.push({
        field: columnName,
        message: `Unexpected field '${columnName}' not defined in schema '${schema.name}'`,
        value,
      });
      continue;
    }

    // For partial validation, ignore the 'required' constraint
    const result = validateColumn(value, { ...columnDef, required: false }, columnName);

    if (!result.valid) {
      errors.push(...result.errors);
    }
  }

  return {
    valid: errors.length === 0,
    errors,
  };
};

Version 3

'use strict';

import { ZodError } from 'zod';
import { Schema, SchemaColumn } from '../types';

export type ValidationError = {
  field: string;
  message: string;
  value?: unknown;
};

export type ValidationResult = {
  valid: boolean;
  errors: ValidationError[];
};

/**
 * Validate a single column value against its schema definition
 */
export const validateColumn = (
  value: unknown,
  column: SchemaColumn,
  fieldName?: string
): ValidationResult => {
  const errors: ValidationError[] = [];
  const field = fieldName || column.name;

  // Use Zod validation if zodValidator is present
  if (column.zodValidator) {
    try {
      column.zodValidator.parse(value);
      return { valid: true, errors: [] };
    } catch (error) {
      if (error instanceof ZodError) {
        // Convert Zod errors to our ValidationError format
        const zodErrors = error.errors.map((err) => ({
          field,
          message: err.message,
          value,
        }));
        return { valid: false, errors: zodErrors };
      }
      // Re-throw unexpected errors
      throw error;
    }
  }

  // Fall back to custom validation when no zodValidator

  // Check required
  if (column.required && (value === null || value === undefined)) {
    errors.push({
      field,
      message: `Field '${field}' is required`,
      value,
    });
    return { valid: false, errors };
  }

  // If value is null/undefined and not required, skip further validation
  if (value === null || value === undefined) {
    return { valid: true, errors: [] };
  }

  // Type validation
  const actualType = typeof value;
  let expectedType = column.type;
  if (expectedType === 'object') expectedType = 'object';

  if (actualType !== expectedType) {
    errors.push({
      field,
      message: `Field '${field}' must be of type ${column.type}, got ${actualType}`,
      value,
    });
    return { valid: false, errors };
  }

  // String validation
  if (column.type === 'string' && typeof value === 'string') {
    if (column.minLength !== undefined && value.length < column.minLength) {
      errors.push({
        field,
        message: `Field '${field}' must be at least ${column.minLength} characters, got ${value.length}`,
        value,
      });
    }

    if (column.maxLength !== undefined && value.length > column.maxLength) {
      errors.push({
        field,
        message: `Field '${field}' must be at most ${column.maxLength} characters, got ${value.length}`,
        value,
      });
    }

    if (column.regex && !column.regex.test(value)) {
      errors.push({
        field,
        message: `Field '${field}' does not match required format`,
        value,
      });
    }

    if (column.values && !column.values.includes(value)) {
      errors.push({
        field,
        message: `Field '${field}' must be one of: [${column.values.join(', ')}], got '${value}'`,
        value,
      });
    }
  }

  // Number validation
  if (column.type === 'number' && typeof value === 'number') {
    if (column.minValue !== undefined && value < column.minValue) {
      errors.push({
        field,
        message: `Field '${field}' must be at least ${column.minValue}, got ${value}`,
        value,
      });
    }

    if (column.maxValue !== undefined && value > column.maxValue) {
      errors.push({
        field,
        message: `Field '${field}' must be at most ${column.maxValue}, got ${value}`,
        value,
      });
    }
  }

  return {
    valid: errors.length === 0,
    errors,
  };
};

/**
 * Validate an entire entity against its schema
 */
export const validateEntity = (data: Record<string, unknown>, schema: Schema): ValidationResult => {
  const errors: ValidationError[] = [];

  // Validate each column in the schema
  for (const [columnName, columnDef] of Object.entries(schema.columns)) {
    const value = data[columnName];
    const result = validateColumn(value, columnDef, columnName);

    if (!result.valid) {
      errors.push(...result.errors);
    }
  }

  // Check for unexpected fields
  for (const key of Object.keys(data)) {
    if (!schema.columns[key]) {
      errors.push({
        field: key,
        message: `Unexpected field '${key}' not defined in schema '${schema.name}'`,
        value: data[key],
      });
    }
  }

  return {
    valid: errors.length === 0,
    errors,
  };
};

/**
 * Validate a partial entity (useful for updates where not all fields are provided)
 */
export const validatePartialEntity = (
  data: Record<string, unknown>,
  schema: Schema
): ValidationResult => {
  const errors: ValidationError[] = [];

  // Only validate fields that are present in the data
  for (const [columnName, value] of Object.entries(data)) {
    const columnDef = schema.columns[columnName];

    if (!columnDef) {
      errors.push({
        field: columnName,
        message: `Unexpected field '${columnName}' not defined in schema '${schema.name}'`,
        value,
      });
      continue;
    }

    // For partial validation, ignore the 'required' constraint
    const result = validateColumn(value, { ...columnDef, required: false }, columnName);

    if (!result.valid) {
      errors.push(...result.errors);
    }
  }

  return {
    valid: errors.length === 0,
    errors,
  };
};

Version 4 (latest)

'use strict';

import { ZodError } from 'zod';
import { Schema, SchemaColumn } from '../types';

export type ValidationError = {
  field: string;
  message: string;
  value?: unknown;
};

export type ValidationResult = {
  valid: boolean;
  errors: ValidationError[];
};

/**
 * Validate a single column value against its schema definition
 */
export const validateColumn = (
  value: unknown,
  column: SchemaColumn,
  fieldName?: string
): ValidationResult => {
  const errors: ValidationError[] = [];
  const field = fieldName || column.name;

  // Use Zod validation if zodValidator is present
  if (column.zodValidator) {
    try {
      column.zodValidator.parse(value);
      return { valid: true, errors: [] };
    } catch (error) {
      if (error instanceof ZodError) {
        // Convert Zod errors to our ValidationError format
        const zodErrors = error.errors.map((err) => ({
          field,
          message: err.message,
          value,
        }));
        return { valid: false, errors: zodErrors };
      }
      // Re-throw unexpected errors
      throw error;
    }
  }

  // Fall back to custom validation when no zodValidator

  // Check required
  if (column.required && (value === null || value === undefined)) {
    errors.push({
      field,
      message: `Field '${field}' is required`,
      value,
    });
    return { valid: false, errors };
  }

  // If value is null/undefined and not required, skip further validation
  if (value === null || value === undefined) {
    return { valid: true, errors: [] };
  }

  // Type validation
  const actualType = typeof value;
  let expectedType = column.type;
  if (expectedType === 'object') expectedType = 'object';

  if (actualType !== expectedType) {
    errors.push({
      field,
      message: `Field '${field}' must be of type ${column.type}, got ${actualType}`,
      value,
    });
    return { valid: false, errors };
  }

  // String validation
  if (column.type === 'string' && typeof value === 'string') {
    if (column.minLength !== undefined && value.length < column.minLength) {
      errors.push({
        field,
        message: `Field '${field}' must be at least ${column.minLength} characters, got ${value.length}`,
        value,
      });
    }

    if (column.maxLength !== undefined && value.length > column.maxLength) {
      errors.push({
        field,
        message: `Field '${field}' must be at most ${column.maxLength} characters, got ${value.length}`,
        value,
      });
    }

    if (column.regex && !column.regex.test(value)) {
      errors.push({
        field,
        message: `Field '${field}' does not match required format`,
        value,
      });
    }

    if (column.values && !column.values.includes(value)) {
      errors.push({
        field,
        message: `Field '${field}' must be one of: [${column.values.join(', ')}], got '${value}'`,
        value,
      });
    }
  }

  // Number validation
  if (column.type === 'number' && typeof value === 'number') {
    if (column.minValue !== undefined && value < column.minValue) {
      errors.push({
        field,
        message: `Field '${field}' must be at least ${column.minValue}, got ${value}`,
        value,
      });
    }

    if (column.maxValue !== undefined && value > column.maxValue) {
      errors.push({
        field,
        message: `Field '${field}' must be at most ${column.maxValue}, got ${value}`,
        value,
      });
    }
  }

  return {
    valid: errors.length === 0,
    errors,
  };
};

/**
 * Validate an entire entity against its schema
 */
export const validateEntity = (data: Record<string, unknown>, schema: Schema): ValidationResult => {
  const errors: ValidationError[] = [];

  // Validate each column in the schema
  for (const [columnName, columnDef] of Object.entries(schema.columns)) {
    const value = data[columnName];
    const result = validateColumn(value, columnDef, columnName);

    if (!result.valid) {
      errors.push(...result.errors);
    }
  }

  // Check for unexpected fields
  for (const key of Object.keys(data)) {
    if (!schema.columns[key]) {
      errors.push({
        field: key,
        message: `Unexpected field '${key}' not defined in schema '${schema.name}'`,
        value: data[key],
      });
    }
  }

  return {
    valid: errors.length === 0,
    errors,
  };
};

/**
 * Validate a partial entity (useful for updates where not all fields are provided)
 */
export const validatePartialEntity = (
  data: Record<string, unknown>,
  schema: Schema
): ValidationResult => {
  const errors: ValidationError[] = [];

  // Only validate fields that are present in the data
  for (const [columnName, value] of Object.entries(data)) {
    const columnDef = schema.columns[columnName];

    if (!columnDef) {
      errors.push({
        field: columnName,
        message: `Unexpected field '${columnName}' not defined in schema '${schema.name}'`,
        value,
      });
      continue;
    }

    // For partial validation, ignore the 'required' constraint
    const result = validateColumn(value, { ...columnDef, required: false }, columnName);

    if (!result.valid) {
      errors.push(...result.errors);
    }
  }

  return {
    valid: errors.length === 0,
    errors,
  };
};

packages/cwc-schema/src/validation/zodValidators.ts

3 versions

Version 1

'use strict';

import { z } from 'zod';

/**
 * Example Zod validators for complex validation scenarios.
 *
 * Use Zod validators when:
 * - Password strength requirements (uppercase, lowercase, numbers, special chars)
 * - Conditional validation (different rules based on other fields)
 * - Cross-field validation (one field depends on another)
 * - Complex business logic (custom refinements)
 * - Advanced string parsing (dates, URLs, transforms)
 *
 * Use custom validation when:
 * - Simple min/max length checks
 * - Simple regex patterns
 * - Basic enum values
 * - Basic type checking
 */

/**
 * Password strength validator
 *
 * Requirements:
 * - At least 8 characters
 * - At least one uppercase letter
 * - At least one lowercase letter
 * - At least one number
 * - At least one special character
 *
 * Usage:
 * ```typescript
 * password: {
 *   ...password,
 *   zodValidator: passwordStrengthValidator,
 * }
 * ```
 */
export const passwordStrengthValidator = z
  .string()
  .min(8, 'Password must be at least 8 characters')
  .max(100, 'Password must be at most 100 characters')
  .refine((val) => /[A-Z]/.test(val), {
    message: 'Password must contain at least one uppercase letter',
  })
  .refine((val) => /[a-z]/.test(val), {
    message: 'Password must contain at least one lowercase letter',
  })
  .refine((val) => /[0-9]/.test(val), {
    message: 'Password must contain at least one number',
  })
  .refine((val) => /[^A-Za-z0-9]/.test(val), {
    message: 'Password must contain at least one special character',
  });

/**
 * Email validator with stricter rules than basic regex
 *
 * Requirements:
 * - Valid email format
 * - No consecutive dots
 * - No leading/trailing dots in local part
 * - Domain must have at least 2 parts
 *
 * Usage:
 * ```typescript
 * email: {
 *   ...email,
 *   zodValidator: strictEmailValidator,
 * }
 * ```
 */
export const strictEmailValidator = z
  .string()
  .email('Invalid email format')
  .refine((val) => !val.includes('..'), {
    message: 'Email cannot contain consecutive dots',
  })
  .refine((val) => {
    const [localPart] = val.split('@');
    if (!localPart) return false;
    return !localPart.startsWith('.') && !localPart.endsWith('.');
  }, {
    message: 'Email local part cannot start or end with a dot',
  });

/**
 * Username validator with profanity check
 *
 * Requirements:
 * - 4-100 alphanumeric characters or underscores
 * - No profanity (example blacklist)
 *
 * Usage:
 * ```typescript
 * username: {
 *   ...username,
 *   zodValidator: usernameWithProfanityCheck,
 * }
 * ```
 */
const profanityBlacklist = ['badword1', 'badword2', 'admin', 'root', 'system'];

export const usernameWithProfanityCheck = z
  .string()
  .min(4, 'Username must be at least 4 characters')
  .max(100, 'Username must be at most 100 characters')
  .regex(/^[a-zA-Z0-9_]+$/, 'Username can only contain letters, numbers, and underscores')
  .refine((val) => !profanityBlacklist.some((word) => val.toLowerCase().includes(word)), {
    message: 'Username contains prohibited words',
  });

/**
 * URL validator with allowed domains
 *
 * Requirements:
 * - Valid URL format
 * - HTTPS only
 * - Must be from allowed domains
 *
 * Usage:
 * ```typescript
 * websiteUrl: {
 *   type: 'string',
 *   name: 'websiteUrl',
 *   typename: 'url',
 *   zodValidator: allowedDomainsUrlValidator(['example.com', 'mysite.com']),
 * }
 * ```
 */
export const allowedDomainsUrlValidator = (allowedDomains: string[]) =>
  z
    .string()
    .url('Invalid URL format')
    .refine((val) => val.startsWith('https://'), {
      message: 'URL must use HTTPS',
    })
    .refine(
      (val) => {
        // Extract hostname from URL string (simpler than URL constructor)
        const match = val.match(/^https?:\/\/([^/:]+)/);
        if (!match || !match[1]) return false;
        const hostname = match[1];
        return allowedDomains.some((domain) => hostname === domain || hostname.endsWith(`.${domain}`));
      },
      {
        message: `URL must be from allowed domains: ${allowedDomains.join(', ')}`,
      }
    );

/**
 * Conditional validator example: different rules based on login type
 *
 * This shows how to create validators that change behavior based on context.
 * Note: For cross-field validation, you'd typically validate at the entity level,
 * not the column level. This is a simplified example.
 *
 * Usage:
 * ```typescript
 * // In a custom validation function at entity level:
 * const loginType = data.loginType as string;
 * const passwordValidator = loginType === 'cwc' ? passwordRequiredValidator : passwordOptionalValidator;
 * ```
 */
export const passwordRequiredValidator = z
  .string()
  .min(1, 'Password is required for CWC login');

export const passwordOptionalValidator = z
  .string()
  .optional()
  .nullable();

/**
 * Date range validator
 *
 * Ensures date is within acceptable range (e.g., not in future, not too old)
 *
 * Usage:
 * ```typescript
 * birthDate: {
 *   type: 'string',
 *   name: 'birthDate',
 *   typename: 'date',
 *   zodValidator: dateRangeValidator({ minYearsAgo: 100, maxYearsAgo: 13 }),
 * }
 * ```
 */
export const dateRangeValidator = (options: { minYearsAgo?: number; maxYearsAgo?: number }) =>
  z.string().refine(
    (val) => {
      const date = new Date(val);
      if (isNaN(date.getTime())) return false;

      const now = new Date();
      const minDate = options.minYearsAgo
        ? new Date(now.getFullYear() - options.minYearsAgo, now.getMonth(), now.getDate())
        : new Date(0);
      const maxDate = options.maxYearsAgo
        ? new Date(now.getFullYear() - options.maxYearsAgo, now.getMonth(), now.getDate())
        : now;

      return date >= minDate && date <= maxDate;
    },
    {
      message: `Date must be between ${options.minYearsAgo || 0} and ${options.maxYearsAgo || 0} years ago`,
    }
  );

/**
 * JSON string validator with schema
 *
 * Validates that a string is valid JSON and matches a specific structure
 *
 * Usage:
 * ```typescript
 * metadata: {
 *   type: 'string',
 *   name: 'metadata',
 *   typename: 'json',
 *   zodValidator: jsonStringValidator(z.object({
 *     version: z.string(),
 *     timestamp: z.number(),
 *   })),
 * }
 * ```
 */
export const jsonStringValidator = <T extends z.ZodType>(schema: T) =>
  z.string().transform((val, ctx) => {
    try {
      const parsed = JSON.parse(val);
      const result = schema.safeParse(parsed);
      if (!result.success) {
        result.error.errors.forEach((err) => {
          ctx.addIssue({
            code: z.ZodIssueCode.custom,
            message: `Invalid JSON structure: ${err.message}`,
          });
        });
        return z.NEVER;
      }
      return parsed;
    } catch {
      ctx.addIssue({
        code: z.ZodIssueCode.custom,
        message: 'Invalid JSON string',
      });
      return z.NEVER;
    }
  });

Version 2

'use strict';

import { z } from 'zod';

/**
 * Example Zod validators for complex validation scenarios.
 *
 * Use Zod validators when:
 * - Password strength requirements (uppercase, lowercase, numbers, special chars)
 * - Conditional validation (different rules based on other fields)
 * - Cross-field validation (one field depends on another)
 * - Complex business logic (custom refinements)
 * - Advanced string parsing (dates, URLs, transforms)
 *
 * Use custom validation when:
 * - Simple min/max length checks
 * - Simple regex patterns
 * - Basic enum values
 * - Basic type checking
 */

/**
 * Password strength validator
 *
 * Requirements:
 * - At least 8 characters
 * - At least one uppercase letter
 * - At least one lowercase letter
 * - At least one number
 * - At least one special character
 *
 * Usage:
 * ```typescript
 * password: {
 *   ...password,
 *   zodValidator: passwordStrengthValidator,
 * }
 * ```
 */
export const passwordStrengthValidator = z
  .string()
  .min(8, 'Password must be at least 8 characters')
  .max(100, 'Password must be at most 100 characters')
  .refine((val) => /[A-Z]/.test(val), {
    message: 'Password must contain at least one uppercase letter',
  })
  .refine((val) => /[a-z]/.test(val), {
    message: 'Password must contain at least one lowercase letter',
  })
  .refine((val) => /[0-9]/.test(val), {
    message: 'Password must contain at least one number',
  })
  .refine((val) => /[^A-Za-z0-9]/.test(val), {
    message: 'Password must contain at least one special character',
  });

/**
 * Email validator with stricter rules than basic regex
 *
 * Requirements:
 * - Valid email format
 * - No consecutive dots
 * - No leading/trailing dots in local part
 * - Domain must have at least 2 parts
 *
 * Usage:
 * ```typescript
 * email: {
 *   ...email,
 *   zodValidator: strictEmailValidator,
 * }
 * ```
 */
export const strictEmailValidator = z
  .string()
  .email('Invalid email format')
  .refine((val) => !val.includes('..'), {
    message: 'Email cannot contain consecutive dots',
  })
  .refine((val) => {
    const [localPart] = val.split('@');
    if (!localPart) return false;
    return !localPart.startsWith('.') && !localPart.endsWith('.');
  }, {
    message: 'Email local part cannot start or end with a dot',
  });

/**
 * Username validator with profanity check
 *
 * Requirements:
 * - 4-100 alphanumeric characters or underscores
 * - No profanity (example blacklist)
 *
 * Usage:
 * ```typescript
 * username: {
 *   ...username,
 *   zodValidator: usernameWithProfanityCheck,
 * }
 * ```
 */
const profanityBlacklist = ['badword1', 'badword2', 'admin', 'root', 'system'];

export const usernameWithProfanityCheck = z
  .string()
  .min(4, 'Username must be at least 4 characters')
  .max(100, 'Username must be at most 100 characters')
  .regex(/^[a-zA-Z0-9_]+$/, 'Username can only contain letters, numbers, and underscores')
  .refine((val) => !profanityBlacklist.some((word) => val.toLowerCase().includes(word)), {
    message: 'Username contains prohibited words',
  });

/**
 * URL validator with allowed domains
 *
 * Requirements:
 * - Valid URL format
 * - HTTPS only
 * - Must be from allowed domains
 *
 * Usage:
 * ```typescript
 * websiteUrl: {
 *   type: 'string',
 *   name: 'websiteUrl',
 *   typename: 'url',
 *   zodValidator: allowedDomainsUrlValidator(['example.com', 'mysite.com']),
 * }
 * ```
 */
export const allowedDomainsUrlValidator = (allowedDomains: string[]) =>
  z
    .string()
    .url('Invalid URL format')
    .refine((val) => val.startsWith('https://'), {
      message: 'URL must use HTTPS',
    })
    .refine(
      (val) => {
        // Extract hostname from URL string (simpler than URL constructor)
        const match = val.match(/^https?:\/\/([^/:]+)/);
        if (!match || !match[1]) return false;
        const hostname = match[1];
        return allowedDomains.some((domain) => hostname === domain || hostname.endsWith(`.${domain}`));
      },
      {
        message: `URL must be from allowed domains: ${allowedDomains.join(', ')}`,
      }
    );

/**
 * Conditional validator example: different rules based on login type
 *
 * This shows how to create validators that change behavior based on context.
 * Note: For cross-field validation, you'd typically validate at the entity level,
 * not the column level. This is a simplified example.
 *
 * Usage:
 * ```typescript
 * // In a custom validation function at entity level:
 * const loginType = data.loginType as string;
 * const passwordValidator = loginType === 'cwc' ? passwordRequiredValidator : passwordOptionalValidator;
 * ```
 */
export const passwordRequiredValidator = z
  .string()
  .min(1, 'Password is required for CWC login');

export const passwordOptionalValidator = z
  .string()
  .optional()
  .nullable();

/**
 * Date range validator
 *
 * Ensures date is within acceptable range (e.g., not in future, not too old)
 *
 * Usage:
 * ```typescript
 * birthDate: {
 *   type: 'string',
 *   name: 'birthDate',
 *   typename: 'date',
 *   zodValidator: dateRangeValidator({ minYearsAgo: 100, maxYearsAgo: 13 }),
 * }
 * ```
 */
export const dateRangeValidator = (options: { minYearsAgo?: number; maxYearsAgo?: number }) =>
  z.string().refine(
    (val) => {
      const date = new Date(val);
      if (isNaN(date.getTime())) return false;

      const now = new Date();
      const minDate = options.minYearsAgo
        ? new Date(now.getFullYear() - options.minYearsAgo, now.getMonth(), now.getDate())
        : new Date(0);
      const maxDate = options.maxYearsAgo
        ? new Date(now.getFullYear() - options.maxYearsAgo, now.getMonth(), now.getDate())
        : now;

      return date >= minDate && date <= maxDate;
    },
    {
      message: `Date must be between ${options.minYearsAgo || 0} and ${options.maxYearsAgo || 0} years ago`,
    }
  );

/**
 * JSON string validator with schema
 *
 * Validates that a string is valid JSON and matches a specific structure
 *
 * Usage:
 * ```typescript
 * metadata: {
 *   type: 'string',
 *   name: 'metadata',
 *   typename: 'json',
 *   zodValidator: jsonStringValidator(z.object({
 *     version: z.string(),
 *     timestamp: z.number(),
 *   })),
 * }
 * ```
 */
export const jsonStringValidator = <T extends z.ZodType>(schema: T) =>
  z.string().transform((val, ctx) => {
    try {
      const parsed = JSON.parse(val);
      const result = schema.safeParse(parsed);
      if (!result.success) {
        result.error.errors.forEach((err) => {
          ctx.addIssue({
            code: z.ZodIssueCode.custom,
            message: `Invalid JSON structure: ${err.message}`,
          });
        });
        return z.NEVER;
      }
      return parsed;
    } catch {
      ctx.addIssue({
        code: z.ZodIssueCode.custom,
        message: 'Invalid JSON string',
      });
      return z.NEVER;
    }
  });

Version 3 (latest)

'use strict';

import { z } from 'zod';

/**
 * Example Zod validators for complex validation scenarios.
 *
 * Use Zod validators when:
 * - Password strength requirements (uppercase, lowercase, numbers, special chars)
 * - Conditional validation (different rules based on other fields)
 * - Cross-field validation (one field depends on another)
 * - Complex business logic (custom refinements)
 * - Advanced string parsing (dates, URLs, transforms)
 *
 * Use custom validation when:
 * - Simple min/max length checks
 * - Simple regex patterns
 * - Basic enum values
 * - Basic type checking
 */

/**
 * Password strength validator
 *
 * Requirements:
 * - At least 8 characters
 * - At least one uppercase letter
 * - At least one lowercase letter
 * - At least one number
 * - At least one special character
 *
 * Usage:
 * ```typescript
 * password: {
 *   ...password,
 *   zodValidator: passwordStrengthValidator,
 * }
 * ```
 */
export const passwordStrengthValidator = z
  .string()
  .min(8, 'Password must be at least 8 characters')
  .max(100, 'Password must be at most 100 characters')
  .refine((val) => /[A-Z]/.test(val), {
    message: 'Password must contain at least one uppercase letter',
  })
  .refine((val) => /[a-z]/.test(val), {
    message: 'Password must contain at least one lowercase letter',
  })
  .refine((val) => /[0-9]/.test(val), {
    message: 'Password must contain at least one number',
  })
  .refine((val) => /[^A-Za-z0-9]/.test(val), {
    message: 'Password must contain at least one special character',
  });

/**
 * Email validator with stricter rules than basic regex
 *
 * Requirements:
 * - Valid email format
 * - No consecutive dots
 * - No leading/trailing dots in local part
 * - Domain must have at least 2 parts
 *
 * Usage:
 * ```typescript
 * email: {
 *   ...email,
 *   zodValidator: strictEmailValidator,
 * }
 * ```
 */
export const strictEmailValidator = z
  .string()
  .email('Invalid email format')
  .refine((val) => !val.includes('..'), {
    message: 'Email cannot contain consecutive dots',
  })
  .refine((val) => {
    const [localPart] = val.split('@');
    if (!localPart) return false;
    return !localPart.startsWith('.') && !localPart.endsWith('.');
  }, {
    message: 'Email local part cannot start or end with a dot',
  });

/**
 * URL validator with allowed domains
 *
 * Requirements:
 * - Valid URL format
 * - HTTPS only
 * - Must be from allowed domains
 *
 * Usage:
 * ```typescript
 * websiteUrl: {
 *   type: 'string',
 *   name: 'websiteUrl',
 *   typename: 'url',
 *   zodValidator: allowedDomainsUrlValidator(['example.com', 'mysite.com']),
 * }
 * ```
 */
export const allowedDomainsUrlValidator = (allowedDomains: string[]) =>
  z
    .string()
    .url('Invalid URL format')
    .refine((val) => val.startsWith('https://'), {
      message: 'URL must use HTTPS',
    })
    .refine(
      (val) => {
        // Extract hostname from URL string (simpler than URL constructor)
        const match = val.match(/^https?:\/\/([^/:]+)/);
        if (!match || !match[1]) return false;
        const hostname = match[1];
        return allowedDomains.some((domain) => hostname === domain || hostname.endsWith(`.${domain}`));
      },
      {
        message: `URL must be from allowed domains: ${allowedDomains.join(', ')}`,
      }
    );

/**
 * Conditional validator example: different rules based on login type
 *
 * This shows how to create validators that change behavior based on context.
 * Note: For cross-field validation, you'd typically validate at the entity level,
 * not the column level. This is a simplified example.
 *
 * Usage:
 * ```typescript
 * // In a custom validation function at entity level:
 * const loginType = data.loginType as string;
 * const passwordValidator = loginType === 'cwc' ? passwordRequiredValidator : passwordOptionalValidator;
 * ```
 */
export const passwordRequiredValidator = z
  .string()
  .min(1, 'Password is required for CWC login');

export const passwordOptionalValidator = z
  .string()
  .optional()
  .nullable();

/**
 * Date range validator
 *
 * Ensures date is within acceptable range (e.g., not in future, not too old)
 *
 * Usage:
 * ```typescript
 * birthDate: {
 *   type: 'string',
 *   name: 'birthDate',
 *   typename: 'date',
 *   zodValidator: dateRangeValidator({ minYearsAgo: 100, maxYearsAgo: 13 }),
 * }
 * ```
 */
export const dateRangeValidator = (options: { minYearsAgo?: number; maxYearsAgo?: number }) =>
  z.string().refine(
    (val) => {
      const date = new Date(val);
      if (isNaN(date.getTime())) return false;

      const now = new Date();
      const minDate = options.minYearsAgo
        ? new Date(now.getFullYear() - options.minYearsAgo, now.getMonth(), now.getDate())
        : new Date(0);
      const maxDate = options.maxYearsAgo
        ? new Date(now.getFullYear() - options.maxYearsAgo, now.getMonth(), now.getDate())
        : now;

      return date >= minDate && date <= maxDate;
    },
    {
      message: `Date must be between ${options.minYearsAgo || 0} and ${options.maxYearsAgo || 0} years ago`,
    }
  );

/**
 * JSON string validator with schema
 *
 * Validates that a string is valid JSON and matches a specific structure
 *
 * Usage:
 * ```typescript
 * metadata: {
 *   type: 'string',
 *   name: 'metadata',
 *   typename: 'json',
 *   zodValidator: jsonStringValidator(z.object({
 *     version: z.string(),
 *     timestamp: z.number(),
 *   })),
 * }
 * ```
 */
export const jsonStringValidator = <T extends z.ZodType>(schema: T) =>
  z.string().transform((val, ctx) => {
    try {
      const parsed = JSON.parse(val);
      const result = schema.safeParse(parsed);
      if (!result.success) {
        result.error.errors.forEach((err) => {
          ctx.addIssue({
            code: z.ZodIssueCode.custom,
            message: `Invalid JSON structure: ${err.message}`,
          });
        });
        return z.NEVER;
      }
      return parsed;
    } catch {
      ctx.addIssue({
        code: z.ZodIssueCode.custom,
        message: 'Invalid JSON string',
      });
      return z.NEVER;
    }
  });

packages/cwc-schema/tsconfig.json

2 versions

Version 1

{
  "extends": "../../tsconfig.base.json",
  "compilerOptions": {
    "composite": true,
    "rootDir": "./src",
    "outDir": "./dist"
  },
  "include": ["src/**/*"],
  "exclude": ["node_modules", "dist"]
}

Version 2 (latest)

{
  "extends": "../../tsconfig.base.json",
  "compilerOptions": {
    "composite": true,
    "rootDir": "./src",
    "outDir": "./dist"
  },
  "include": ["src/**/*"],
  "exclude": ["node_modules", "dist"]
}

packages/cwc-utils/CLAUDE.md

2 versions

Version 1

cwc-utils Package

Shared utilities for the CWC application. Cross-platform compatible (browser and Node.js).

Package Purpose

Provide shared business logic utilities used across multiple CWC packages
Cross-platform compatible - works in both browser (React) and Node.js environments
Zero runtime dependencies (aligns with "roll-your-own" philosophy)
Tree-shakeable for optimal bundle size

Package Structure

cwc-utils/
├── src/
│   ├── profanity/
│   │   ├── word-list.ts           - Profanity word list (LDNOOBW source)
│   │   └── profanityChecker.ts    - Profanity detection utilities
│   └── index.ts                   - Main exports
└── dist/                          - Compiled output

Current Utilities

Profanity Checking

Utilities for detecting inappropriate content in user-generated text (usernames, project IDs, etc.).

Source: LDNOOBW (List of Dirty, Naughty, Obscene, and Otherwise Bad Words) License: Public Domain Word Count: 400+ English words

API Reference

containsProfanity(text, options?)

Check if text contains any profane words.

import { containsProfanity } from 'cwc-utils';

// Basic usage
containsProfanity('hello world'); // false
containsProfanity('badword'); // true

// With leetspeak detection
containsProfanity('b@dw0rd', { detectLeetspeak: true }); // true

Parameters:

text (string) - The text to check
options.detectLeetspeak (boolean) - Apply leetspeak normalization (default: false)

Returns: boolean

getProfaneWords(text, options?)

Get all profane words found in text.

import { getProfaneWords } from 'cwc-utils';

getProfaneWords('hello badword1 world badword2');
// Returns: ['badword1', 'badword2']

getProfaneWords('h3llo b@dw0rd', { detectLeetspeak: true });
// Returns: ['badword'] (after leetspeak normalization)

Parameters:

text (string) - The text to check
options.detectLeetspeak (boolean) - Apply leetspeak normalization (default: false)

Returns: string[]

validateNoProfanity(text, options?)

Validate that text does not contain profanity (returns validation result object).

import { validateNoProfanity } from 'cwc-utils';

const result = validateNoProfanity('clean text');
// { valid: true, error: null }

const result2 = validateNoProfanity('badword');
// { valid: false, error: 'Text contains inappropriate content' }

const result3 = validateNoProfanity('badword', {
  errorMessage: 'Username contains prohibited words'
});
// { valid: false, error: 'Username contains prohibited words' }

Parameters:

text (string) - The text to validate
options.detectLeetspeak (boolean) - Apply leetspeak normalization (default: false)
options.errorMessage (string) - Custom error message (default: 'Text contains inappropriate content')

Returns: { valid: boolean; error: string | null }

Usage Examples

Username Validation (cwc-api)

import { containsProfanity } from 'cwc-utils';

function validateUsername(username: string): { valid: boolean; error?: string } {
  // Check format first
  if (!/^[a-zA-Z0-9_]{4,100}$/.test(username)) {
    return { valid: false, error: 'Invalid username format' };
  }

  // Check profanity
  if (containsProfanity(username)) {
    return { valid: false, error: 'Username contains inappropriate content' };
  }

  return { valid: true };
}

Project ID Validation (cwc-api)

import { validateNoProfanity } from 'cwc-utils';

function validateProjectId(projectId: string): { valid: boolean; error?: string } {
  // Check format
  if (!/^[a-zA-Z0-9-]{1,150}$/.test(projectId)) {
    return { valid: false, error: 'Invalid project ID format' };
  }

  // Check profanity
  const profanityCheck = validateNoProfanity(projectId, {
    errorMessage: 'Project ID contains inappropriate content'
  });

  if (!profanityCheck.valid) {
    return { valid: false, error: profanityCheck.error || undefined };
  }

  return { valid: true };
}

Frontend Validation (cwc-website)

import { containsProfanity } from 'cwc-utils';

function SignupForm() {
  const [username, setUsername] = useState('');
  const [error, setError] = useState('');

  const handleUsernameChange = (e: React.ChangeEvent<HTMLInputElement>) => {
    const value = e.target.value;
    setUsername(value);

    // Real-time profanity check
    if (containsProfanity(value)) {
      setError('Username contains inappropriate content');
    } else {
      setError('');
    }
  };

  return (
    <input
      value={username}
      onChange={handleUsernameChange}
      className={error ? 'error' : ''}
    />
  );
}

Leetspeak Detection

When detectLeetspeak: true is enabled, the checker applies basic character substitution normalization:

Leetspeak	Normalized
0	o
1	i
3	e
4	a
5	s
7	t
8	b
$	s
@	a

Trade-off: Enabling leetspeak detection may increase false positives but catches more variants.

Recommendation: Use for username/projectId validation where users might try to bypass filters.

Customizing the Word List

The word list can be customized by modifying src/profanity/word-list.ts:

// Add custom words
const CUSTOM_WORDS = ['customword1', 'customword2'];
const ALL_WORDS = [...PROFANITY_WORDS, ...CUSTOM_WORDS];

export const PROFANITY_SET = new Set(ALL_WORDS.map((word) => word.toLowerCase()));

When to customize:

Add brand-specific terms
Add context-specific inappropriate terms
Remove words that are acceptable in your domain

Cross-Platform Compatibility

cwc-utils is designed to work in both browser and Node.js environments:

✅ No Node.js-specific APIs (fs, path, etc.) ✅ No browser-specific APIs (DOM, window, etc.) ✅ Pure JavaScript/TypeScript ✅ ES modules output ✅ Tree-shakeable

Bundle Size:

Profanity checker: ~20KB (includes word list)
Tree-shaking: Only import what you use

Tested Environments:

Node.js 22+
Modern browsers (ES2022+ support)
React applications
Express/Fastify backends

Adding New Utilities

When adding new utilities to this package:

Ensure cross-platform compatibility:
- No Node.js-only APIs (fs, path, process, etc.)
- No browser-only APIs (DOM, localStorage, etc.)
- Use standard JavaScript APIs only
Keep dependencies minimal:
- Prefer zero dependencies
- If dependency needed, ensure it's cross-platform
- Document any dependencies clearly
Maintain tree-shakeability:
- Export utilities as named exports
- Avoid side effects in module loading
- Keep utilities independent where possible
Follow existing patterns:
- TypeScript with strict mode
- Comprehensive JSDoc comments
- Include usage examples
- Export from src/index.ts
Update documentation:
- Add section to this CLAUDE.md
- Update root CLAUDE.md if significant
- Include usage examples for both frontend and backend

Guidelines for Shared Utilities

Utilities that belong in cwc-utils:

String manipulation helpers
Validation functions (format, content)
Data formatting/normalization
Business logic helpers used by multiple packages
Cross-cutting concerns (profanity, spam detection, etc.)

Utilities that DON'T belong here:

Node.js-specific utilities → Use cwc-backend-utils
Type definitions → Use cwc-types
Schema definitions → Use cwc-schema
UI components → Package-specific
Database queries → Package-specific

Testing Guidelines

When testing utilities:

Test in both environments:
- Unit tests run in Node.js
- Integration tests should verify browser compatibility
Test edge cases:
- Empty strings
- Unicode characters
- Very long inputs
- Special characters
Performance considerations:
- Profanity checking is O(n) where n = number of words
- Word list lookup is O(1) (Set-based)
- Suitable for real-time validation

Future Enhancements

Potential additions (not implemented yet):

String formatting utilities (slugify, titleCase, etc.)
Email validation
URL validation and parsing
Date formatting helpers
Number formatting helpers
Spam detection utilities
Rate limiting helpers

Related Packages

Consumed By:

cwc-api - Backend API validation
cwc-website - Frontend form validation
cwc-auth - User signup validation
Any package needing shared utilities

Dependencies:

None (zero runtime dependencies)

Related:

cwc-backend-utils - Node.js-specific utilities
cwc-types - Type definitions
cwc-schema - Schema definitions and validation

Version 2 (latest)

cwc-utils Package

Shared utilities for the CWC application. Cross-platform compatible (browser and Node.js).

Package Purpose

Provide shared business logic utilities used across multiple CWC packages
Cross-platform compatible - works in both browser (React) and Node.js environments
Zero runtime dependencies (aligns with "roll-your-own" philosophy)
Tree-shakeable for optimal bundle size

Package Structure

cwc-utils/
├── src/
│   ├── profanity/
│   │   ├── word-list.ts           - Profanity word list (LDNOOBW source)
│   │   └── profanityChecker.ts    - Profanity detection utilities
│   └── index.ts                   - Main exports
└── dist/                          - Compiled output

Current Utilities

Profanity Checking

Utilities for detecting inappropriate content in user-generated text (usernames, project IDs, etc.).

Source: LDNOOBW (List of Dirty, Naughty, Obscene, and Otherwise Bad Words) License: Public Domain Word Count: 400+ English words

API Reference

containsProfanity(text, options?)

Check if text contains any profane words.

import { containsProfanity } from 'cwc-utils';

// Basic usage
containsProfanity('hello world'); // false
containsProfanity('badword'); // true

// With leetspeak detection
containsProfanity('b@dw0rd', { detectLeetspeak: true }); // true

Parameters:

text (string) - The text to check
options.detectLeetspeak (boolean) - Apply leetspeak normalization (default: false)

Returns: boolean

getProfaneWords(text, options?)

Get all profane words found in text.

import { getProfaneWords } from 'cwc-utils';

getProfaneWords('hello badword1 world badword2');
// Returns: ['badword1', 'badword2']

getProfaneWords('h3llo b@dw0rd', { detectLeetspeak: true });
// Returns: ['badword'] (after leetspeak normalization)

Parameters:

text (string) - The text to check
options.detectLeetspeak (boolean) - Apply leetspeak normalization (default: false)

Returns: string[]

validateNoProfanity(text, options?)

Validate that text does not contain profanity (returns validation result object).

import { validateNoProfanity } from 'cwc-utils';

const result = validateNoProfanity('clean text');
// { valid: true, error: null }

const result2 = validateNoProfanity('badword');
// { valid: false, error: 'Text contains inappropriate content' }

const result3 = validateNoProfanity('badword', {
  errorMessage: 'Username contains prohibited words'
});
// { valid: false, error: 'Username contains prohibited words' }

Parameters:

text (string) - The text to validate
options.detectLeetspeak (boolean) - Apply leetspeak normalization (default: false)
options.errorMessage (string) - Custom error message (default: 'Text contains inappropriate content')

Returns: { valid: boolean; error: string | null }

Usage Examples

Username Validation (cwc-api)

import { containsProfanity } from 'cwc-utils';

function validateUsername(username: string): { valid: boolean; error?: string } {
  // Check format first
  if (!/^[a-zA-Z0-9_]{4,100}$/.test(username)) {
    return { valid: false, error: 'Invalid username format' };
  }

  // Check profanity
  if (containsProfanity(username)) {
    return { valid: false, error: 'Username contains inappropriate content' };
  }

  return { valid: true };
}

Project ID Validation (cwc-api)

import { validateNoProfanity } from 'cwc-utils';

function validateProjectId(projectId: string): { valid: boolean; error?: string } {
  // Check format
  if (!/^[a-zA-Z0-9-]{1,150}$/.test(projectId)) {
    return { valid: false, error: 'Invalid project ID format' };
  }

  // Check profanity
  const profanityCheck = validateNoProfanity(projectId, {
    errorMessage: 'Project ID contains inappropriate content'
  });

  if (!profanityCheck.valid) {
    return { valid: false, error: profanityCheck.error || undefined };
  }

  return { valid: true };
}

Frontend Validation (cwc-website)

import { containsProfanity } from 'cwc-utils';

function SignupForm() {
  const [username, setUsername] = useState('');
  const [error, setError] = useState('');

  const handleUsernameChange = (e: React.ChangeEvent<HTMLInputElement>) => {
    const value = e.target.value;
    setUsername(value);

    // Real-time profanity check
    if (containsProfanity(value)) {
      setError('Username contains inappropriate content');
    } else {
      setError('');
    }
  };

  return (
    <input
      value={username}
      onChange={handleUsernameChange}
      className={error ? 'error' : ''}
    />
  );
}

Leetspeak Detection

When detectLeetspeak: true is enabled, the checker applies basic character substitution normalization:

Leetspeak	Normalized
0	o
1	i
3	e
4	a
5	s
7	t
8	b
$	s
@	a

Trade-off: Enabling leetspeak detection may increase false positives but catches more variants.

Recommendation: Use for username/projectId validation where users might try to bypass filters.

Customizing the Word List

The word list can be customized by modifying src/profanity/word-list.ts:

// Add custom words
const CUSTOM_WORDS = ['customword1', 'customword2'];
const ALL_WORDS = [...PROFANITY_WORDS, ...CUSTOM_WORDS];

export const PROFANITY_SET = new Set(ALL_WORDS.map((word) => word.toLowerCase()));

When to customize:

Add brand-specific terms
Add context-specific inappropriate terms
Remove words that are acceptable in your domain

Cross-Platform Compatibility

cwc-utils is designed to work in both browser and Node.js environments:

✅ No Node.js-specific APIs (fs, path, etc.) ✅ No browser-specific APIs (DOM, window, etc.) ✅ Pure JavaScript/TypeScript ✅ ES modules output ✅ Tree-shakeable

Bundle Size:

Profanity checker: ~20KB (includes word list)
Tree-shaking: Only import what you use

Tested Environments:

Node.js 22+
Modern browsers (ES2022+ support)
React applications
Express/Fastify backends

Adding New Utilities

When adding new utilities to this package:

Ensure cross-platform compatibility:
- No Node.js-only APIs (fs, path, process, etc.)
- No browser-only APIs (DOM, localStorage, etc.)
- Use standard JavaScript APIs only
Keep dependencies minimal:
- Prefer zero dependencies
- If dependency needed, ensure it's cross-platform
- Document any dependencies clearly
Maintain tree-shakeability:
- Export utilities as named exports
- Avoid side effects in module loading
- Keep utilities independent where possible
Follow existing patterns:
- TypeScript with strict mode
- Comprehensive JSDoc comments
- Include usage examples
- Export from src/index.ts
Update documentation:
- Add section to this CLAUDE.md
- Update root CLAUDE.md if significant
- Include usage examples for both frontend and backend

Guidelines for Shared Utilities

Utilities that belong in cwc-utils:

String manipulation helpers
Validation functions (format, content)
Data formatting/normalization
Business logic helpers used by multiple packages
Cross-cutting concerns (profanity, spam detection, etc.)

Utilities that DON'T belong here:

Node.js-specific utilities → Use cwc-backend-utils
Type definitions → Use cwc-types
Schema definitions → Use cwc-schema
UI components → Package-specific
Database queries → Package-specific

Testing Guidelines

When testing utilities:

Test in both environments:
- Unit tests run in Node.js
- Integration tests should verify browser compatibility
Test edge cases:
- Empty strings
- Unicode characters
- Very long inputs
- Special characters
Performance considerations:
- Profanity checking is O(n) where n = number of words
- Word list lookup is O(1) (Set-based)
- Suitable for real-time validation

Future Enhancements

Potential additions (not implemented yet):

String formatting utilities (slugify, titleCase, etc.)
Email validation
URL validation and parsing
Date formatting helpers
Number formatting helpers
Spam detection utilities
Rate limiting helpers

Related Packages

Consumed By:

cwc-api - Backend API validation
cwc-website - Frontend form validation
cwc-auth - User signup validation
Any package needing shared utilities

Dependencies:

None (zero runtime dependencies)

Related:

cwc-backend-utils - Node.js-specific utilities
cwc-types - Type definitions
cwc-schema - Schema definitions and validation

packages/cwc-utils/package.json

2 versions

Version 1

{
  "name": "cwc-utils",
  "version": "1.0.0",
  "description": "Shared utilities for CWC application (browser and Node.js compatible)",
  "type": "module",
  "main": "./dist/index.js",
  "types": "./dist/index.d.ts",
  "exports": {
    ".": {
      "types": "./dist/index.d.ts",
      "default": "./dist/index.js"
    }
  },
  "scripts": {
    "build": "tsc",
    "typecheck": "tsc --noEmit"
  },
  "keywords": ["cwc", "utils", "utilities", "shared"],
  "author": "",
  "license": "UNLICENSED",
  "devDependencies": {
    "typescript": "^5.4.0"
  }
}

Version 2 (latest)

{
  "name": "cwc-utils",
  "version": "1.0.0",
  "description": "Shared utilities for CWC application (browser and Node.js compatible)",
  "type": "module",
  "main": "./dist/index.js",
  "types": "./dist/index.d.ts",
  "exports": {
    ".": {
      "types": "./dist/index.d.ts",
      "default": "./dist/index.js"
    }
  },
  "scripts": {
    "build": "tsc",
    "typecheck": "tsc --noEmit"
  },
  "keywords": ["cwc", "utils", "utilities", "shared"],
  "author": "",
  "license": "UNLICENSED",
  "devDependencies": {
    "typescript": "^5.4.0"
  }
}

packages/cwc-utils/src/index.ts

2 versions

Version 1

'use strict';

/**
 * cwc-utils
 *
 * Shared utilities for CWC application (browser and Node.js compatible)
 */

// Profanity checking utilities
export { containsProfanity, getProfaneWords, validateNoProfanity } from './profanity/profanityChecker';
export { PROFANITY_SET, getProfanityListSize } from './profanity/word-list';

Version 2 (latest)

'use strict';

/**
 * cwc-utils
 *
 * Shared utilities for CWC application (browser and Node.js compatible)
 */

// Profanity checking utilities
export { containsProfanity, getProfaneWords, validateNoProfanity } from './profanity/profanityChecker';
export { PROFANITY_SET, getProfanityListSize } from './profanity/word-list';

packages/cwc-utils/src/profanity/profanityChecker.ts

2 versions

Version 1

'use strict';

import { PROFANITY_SET } from './word-list';

/**
 * Normalize text for profanity checking
 * - Converts to lowercase
 * - Removes special characters and spaces
 * - Optionally applies leetspeak normalization
 */
const normalizeText = (text: string, applyLeetspeak = false): string => {
  let normalized = text.toLowerCase().replace(/[^a-z0-9\s]/g, '');

  if (applyLeetspeak) {
    // Basic leetspeak normalization
    normalized = normalized
      .replace(/0/g, 'o')
      .replace(/1/g, 'i')
      .replace(/3/g, 'e')
      .replace(/4/g, 'a')
      .replace(/5/g, 's')
      .replace(/7/g, 't')
      .replace(/8/g, 'b')
      .replace(/\$/g, 's')
      .replace(/@/g, 'a');
  }

  return normalized;
};

/**
 * Check if text contains any profane words
 *
 * @param text - The text to check
 * @param options - Configuration options
 * @param options.detectLeetspeak - Apply leetspeak normalization (default: false)
 * @returns true if profanity is detected, false otherwise
 *
 * @example
 * ```typescript
 * containsProfanity('hello world'); // false
 * containsProfanity('badword123'); // true
 * containsProfanity('b@dw0rd', { detectLeetspeak: true }); // true
 * ```
 */
export const containsProfanity = (
  text: string,
  options: { detectLeetspeak?: boolean } = {}
): boolean => {
  const { detectLeetspeak = false } = options;

  // Check exact text (case-insensitive)
  const normalized = text.toLowerCase();
  if (PROFANITY_SET.has(normalized)) {
    return true;
  }

  // Check individual words
  const words = text.toLowerCase().split(/\s+/);
  for (const word of words) {
    if (PROFANITY_SET.has(word)) {
      return true;
    }
  }

  // Apply leetspeak normalization if requested
  if (detectLeetspeak) {
    const leetspeakNormalized = normalizeText(text, true);
    if (PROFANITY_SET.has(leetspeakNormalized)) {
      return true;
    }

    const leetspeakWords = leetspeakNormalized.split(/\s+/);
    for (const word of leetspeakWords) {
      if (PROFANITY_SET.has(word)) {
        return true;
      }
    }
  }

  return false;
};

/**
 * Get all profane words found in text
 *
 * @param text - The text to check
 * @param options - Configuration options
 * @param options.detectLeetspeak - Apply leetspeak normalization (default: false)
 * @returns Array of profane words found
 *
 * @example
 * ```typescript
 * getProfaneWords('hello badword1 world badword2');
 * // Returns: ['badword1', 'badword2']
 * ```
 */
export const getProfaneWords = (
  text: string,
  options: { detectLeetspeak?: boolean } = {}
): string[] => {
  const { detectLeetspeak = false } = options;
  const foundWords: string[] = [];

  // Check exact text
  const normalized = text.toLowerCase();
  if (PROFANITY_SET.has(normalized)) {
    foundWords.push(normalized);
  }

  // Check individual words
  const words = text.toLowerCase().split(/\s+/);
  for (const word of words) {
    if (PROFANITY_SET.has(word) && !foundWords.includes(word)) {
      foundWords.push(word);
    }
  }

  // Apply leetspeak normalization if requested
  if (detectLeetspeak) {
    const leetspeakNormalized = normalizeText(text, true);
    if (PROFANITY_SET.has(leetspeakNormalized) && !foundWords.includes(leetspeakNormalized)) {
      foundWords.push(leetspeakNormalized);
    }

    const leetspeakWords = leetspeakNormalized.split(/\s+/);
    for (const word of leetspeakWords) {
      if (PROFANITY_SET.has(word) && !foundWords.includes(word)) {
        foundWords.push(word);
      }
    }
  }

  return foundWords;
};

/**
 * Validate that text does not contain profanity
 *
 * @param text - The text to validate
 * @param options - Configuration options
 * @param options.detectLeetspeak - Apply leetspeak normalization (default: false)
 * @param options.errorMessage - Custom error message (default: 'Text contains inappropriate content')
 * @returns Validation result object
 *
 * @example
 * ```typescript
 * const result = validateNoProfanity('clean text');
 * // { valid: true, error: null }
 *
 * const result2 = validateNoProfanity('badword');
 * // { valid: false, error: 'Text contains inappropriate content' }
 * ```
 */
export const validateNoProfanity = (
  text: string,
  options: {
    detectLeetspeak?: boolean;
    errorMessage?: string;
  } = {}
): { valid: boolean; error: string | null } => {
  const { detectLeetspeak = false, errorMessage = 'Text contains inappropriate content' } = options;

  const hasProfanity = containsProfanity(text, { detectLeetspeak });

  return {
    valid: !hasProfanity,
    error: hasProfanity ? errorMessage : null,
  };
};

Version 2 (latest)

'use strict';

import { PROFANITY_SET } from './word-list';

/**
 * Normalize text for profanity checking
 * - Converts to lowercase
 * - Removes special characters and spaces
 * - Optionally applies leetspeak normalization
 */
const normalizeText = (text: string, applyLeetspeak = false): string => {
  let normalized = text.toLowerCase().replace(/[^a-z0-9\s]/g, '');

  if (applyLeetspeak) {
    // Basic leetspeak normalization
    normalized = normalized
      .replace(/0/g, 'o')
      .replace(/1/g, 'i')
      .replace(/3/g, 'e')
      .replace(/4/g, 'a')
      .replace(/5/g, 's')
      .replace(/7/g, 't')
      .replace(/8/g, 'b')
      .replace(/\$/g, 's')
      .replace(/@/g, 'a');
  }

  return normalized;
};

/**
 * Check if text contains any profane words
 *
 * @param text - The text to check
 * @param options - Configuration options
 * @param options.detectLeetspeak - Apply leetspeak normalization (default: false)
 * @returns true if profanity is detected, false otherwise
 *
 * @example
 * ```typescript
 * containsProfanity('hello world'); // false
 * containsProfanity('badword123'); // true
 * containsProfanity('b@dw0rd', { detectLeetspeak: true }); // true
 * ```
 */
export const containsProfanity = (
  text: string,
  options: { detectLeetspeak?: boolean } = {}
): boolean => {
  const { detectLeetspeak = false } = options;

  // Check exact text (case-insensitive)
  const normalized = text.toLowerCase();
  if (PROFANITY_SET.has(normalized)) {
    return true;
  }

  // Check individual words
  const words = text.toLowerCase().split(/\s+/);
  for (const word of words) {
    if (PROFANITY_SET.has(word)) {
      return true;
    }
  }

  // Apply leetspeak normalization if requested
  if (detectLeetspeak) {
    const leetspeakNormalized = normalizeText(text, true);
    if (PROFANITY_SET.has(leetspeakNormalized)) {
      return true;
    }

    const leetspeakWords = leetspeakNormalized.split(/\s+/);
    for (const word of leetspeakWords) {
      if (PROFANITY_SET.has(word)) {
        return true;
      }
    }
  }

  return false;
};

/**
 * Get all profane words found in text
 *
 * @param text - The text to check
 * @param options - Configuration options
 * @param options.detectLeetspeak - Apply leetspeak normalization (default: false)
 * @returns Array of profane words found
 *
 * @example
 * ```typescript
 * getProfaneWords('hello badword1 world badword2');
 * // Returns: ['badword1', 'badword2']
 * ```
 */
export const getProfaneWords = (
  text: string,
  options: { detectLeetspeak?: boolean } = {}
): string[] => {
  const { detectLeetspeak = false } = options;
  const foundWords: string[] = [];

  // Check exact text
  const normalized = text.toLowerCase();
  if (PROFANITY_SET.has(normalized)) {
    foundWords.push(normalized);
  }

  // Check individual words
  const words = text.toLowerCase().split(/\s+/);
  for (const word of words) {
    if (PROFANITY_SET.has(word) && !foundWords.includes(word)) {
      foundWords.push(word);
    }
  }

  // Apply leetspeak normalization if requested
  if (detectLeetspeak) {
    const leetspeakNormalized = normalizeText(text, true);
    if (PROFANITY_SET.has(leetspeakNormalized) && !foundWords.includes(leetspeakNormalized)) {
      foundWords.push(leetspeakNormalized);
    }

    const leetspeakWords = leetspeakNormalized.split(/\s+/);
    for (const word of leetspeakWords) {
      if (PROFANITY_SET.has(word) && !foundWords.includes(word)) {
        foundWords.push(word);
      }
    }
  }

  return foundWords;
};

/**
 * Validate that text does not contain profanity
 *
 * @param text - The text to validate
 * @param options - Configuration options
 * @param options.detectLeetspeak - Apply leetspeak normalization (default: false)
 * @param options.errorMessage - Custom error message (default: 'Text contains inappropriate content')
 * @returns Validation result object
 *
 * @example
 * ```typescript
 * const result = validateNoProfanity('clean text');
 * // { valid: true, error: null }
 *
 * const result2 = validateNoProfanity('badword');
 * // { valid: false, error: 'Text contains inappropriate content' }
 * ```
 */
export const validateNoProfanity = (
  text: string,
  options: {
    detectLeetspeak?: boolean;
    errorMessage?: string;
  } = {}
): { valid: boolean; error: string | null } => {
  const { detectLeetspeak = false, errorMessage = 'Text contains inappropriate content' } = options;

  const hasProfanity = containsProfanity(text, { detectLeetspeak });

  return {
    valid: !hasProfanity,
    error: hasProfanity ? errorMessage : null,
  };
};

packages/cwc-utils/src/profanity/word-list.ts

2 versions

Version 1

'use strict';

/**
 * Profanity word list for content filtering
 *
 * Source: LDNOOBW (List of Dirty, Naughty, Obscene, and Otherwise Bad Words)
 * Repository: https://github.com/LDNOOBW/List-of-Dirty-Naughty-Obscene-and-Otherwise-Bad-Words
 * License: Public Domain / No explicit license (widely used in open source projects)
 * Last Updated: 2024
 *
 * This list contains English profanity and offensive terms.
 * Use responsibly and customize based on your application's needs.
 */

const PROFANITY_WORDS = [
  '2g1c',
  '2 girls 1 cup',
  'acrotomophilia',
  'alabama hot pocket',
  'alaskan pipeline',
  'anal',
  'anilingus',
  'anus',
  'apeshit',
  'arsehole',
  'ass',
  'asshole',
  'assmunch',
  'auto erotic',
  'autoerotic',
  'babeland',
  'baby batter',
  'baby juice',
  'ball gag',
  'ball gravy',
  'ball kicking',
  'ball licking',
  'ball sack',
  'ball sucking',
  'bangbros',
  'bangbus',
  'bareback',
  'barely legal',
  'barenaked',
  'bastard',
  'bastardo',
  'bastinado',
  'bbw',
  'bdsm',
  'beaner',
  'beaners',
  'beaver cleaver',
  'beaver lips',
  'beastiality',
  'bestiality',
  'big black',
  'big breasts',
  'big knockers',
  'big tits',
  'bimbos',
  'birdlock',
  'bitch',
  'bitches',
  'black cock',
  'blonde action',
  'blonde on blonde action',
  'blowjob',
  'blow job',
  'blow your load',
  'blue waffle',
  'blumpkin',
  'bollocks',
  'bondage',
  'boner',
  'boob',
  'boobs',
  'booty call',
  'brown showers',
  'brunette action',
  'bukkake',
  'bulldyke',
  'bullet vibe',
  'bullshit',
  'bung hole',
  'bunghole',
  'busty',
  'butt',
  'buttcheeks',
  'butthole',
  'camel toe',
  'camgirl',
  'camslut',
  'camwhore',
  'carpet muncher',
  'carpetmuncher',
  'chocolate rosebuds',
  'cialis',
  'circlejerk',
  'cleveland steamer',
  'clit',
  'clitoris',
  'clover clamps',
  'clusterfuck',
  'cock',
  'cocks',
  'coprolagnia',
  'coprophilia',
  'cornhole',
  'coon',
  'coons',
  'creampie',
  'cum',
  'cumming',
  'cumshot',
  'cumshots',
  'cunnilingus',
  'cunt',
  'darkie',
  'date rape',
  'daterape',
  'deep throat',
  'deepthroat',
  'dendrophilia',
  'dick',
  'dildo',
  'dingleberry',
  'dingleberries',
  'dirty pillows',
  'dirty sanchez',
  'doggie style',
  'doggiestyle',
  'doggy style',
  'doggystyle',
  'dog style',
  'dolcett',
  'domination',
  'dominatrix',
  'dommes',
  'donkey punch',
  'double dong',
  'double penetration',
  'dp action',
  'dry hump',
  'dvda',
  'eat my ass',
  'ecchi',
  'ejaculation',
  'erotic',
  'erotism',
  'escort',
  'eunuch',
  'fag',
  'faggot',
  'fecal',
  'felch',
  'fellatio',
  'feltch',
  'female squirting',
  'femdom',
  'figging',
  'fingerbang',
  'fingering',
  'fisting',
  'foot fetish',
  'footjob',
  'frotting',
  'fuck',
  'fuck buttons',
  'fuckin',
  'fucking',
  'fucktards',
  'fudge packer',
  'fudgepacker',
  'futanari',
  'gangbang',
  'gang bang',
  'gay sex',
  'genitals',
  'giant cock',
  'girl on',
  'girl on top',
  'girls gone wild',
  'goatcx',
  'goatse',
  'god damn',
  'gokkun',
  'golden shower',
  'goodpoop',
  'goo girl',
  'goregasm',
  'grope',
  'group sex',
  'g-spot',
  'guro',
  'hand job',
  'handjob',
  'hard core',
  'hardcore',
  'hentai',
  'homoerotic',
  'honkey',
  'hooker',
  'horny',
  'hot carl',
  'hot chick',
  'how to kill',
  'how to murder',
  'huge fat',
  'humping',
  'incest',
  'intercourse',
  'jack off',
  'jail bait',
  'jailbait',
  'jelly donut',
  'jerk off',
  'jigaboo',
  'jiggaboo',
  'jiggerboo',
  'jizz',
  'juggs',
  'kike',
  'kinbaku',
  'kinkster',
  'kinky',
  'knobbing',
  'leather restraint',
  'leather straight jacket',
  'lemon party',
  'livesex',
  'lolita',
  'lovemaking',
  'make me come',
  'male squirting',
  'masturbate',
  'masturbating',
  'masturbation',
  'menage a trois',
  'milf',
  'missionary position',
  'mong',
  'motherfucker',
  'mound of venus',
  'mr hands',
  'muff diver',
  'muffdiving',
  'nambla',
  'nawashi',
  'negro',
  'neonazi',
  'nigga',
  'nigger',
  'nig nog',
  'nimphomania',
  'nipple',
  'nipples',
  'nsfw',
  'nsfw images',
  'nude',
  'nudity',
  'nutten',
  'nympho',
  'nymphomania',
  'octopussy',
  'omorashi',
  'one cup two girls',
  'one guy one jar',
  'orgasm',
  'orgy',
  'paedophile',
  'paki',
  'panties',
  'panty',
  'pedobear',
  'pedophile',
  'pegging',
  'penis',
  'phone sex',
  'piece of shit',
  'pikey',
  'pissing',
  'piss pig',
  'pisspig',
  'playboy',
  'pleasure chest',
  'pole smoker',
  'ponyplay',
  'poof',
  'poon',
  'poontang',
  'punany',
  'poop chute',
  'poopchute',
  'porn',
  'porno',
  'pornography',
  'prince albert piercing',
  'pthc',
  'pubes',
  'pussy',
  'queaf',
  'queef',
  'quim',
  'raghead',
  'raging boner',
  'rape',
  'raping',
  'rapist',
  'rectum',
  'reverse cowgirl',
  'rimjob',
  'rimming',
  'rosy palm',
  'rosy palm and her 5 sisters',
  'rusty trombone',
  'sadism',
  'santorum',
  'scat',
  'schlong',
  'scissoring',
  'semen',
  'sex',
  'sexcam',
  'sexo',
  'sexy',
  'sexual',
  'sexually',
  'sexuality',
  'shaved beaver',
  'shaved pussy',
  'shemale',
  'shibari',
  'shit',
  'shitblimp',
  'shitty',
  'shota',
  'shrimping',
  'skeet',
  'slanteye',
  'slut',
  's&m',
  'smut',
  'snatch',
  'snowballing',
  'sodomize',
  'sodomy',
  'spastic',
  'spic',
  'splooge',
  'splooge moose',
  'spooge',
  'spread legs',
  'spunk',
  'strap on',
  'strapon',
  'strappado',
  'strip club',
  'style doggy',
  'suck',
  'sucks',
  'suicide girls',
  'sultry women',
  'swastika',
  'swinger',
  'tainted love',
  'taste my',
  'tea bagging',
  'threesome',
  'throating',
  'thumbzilla',
  'tied up',
  'tight white',
  'tit',
  'tits',
  'titties',
  'titty',
  'tongue in a',
  'topless',
  'tosser',
  'towelhead',
  'tranny',
  'tribadism',
  'tub girl',
  'tubgirl',
  'tushy',
  'twat',
  'twink',
  'twinkie',
  'two girls one cup',
  'undressing',
  'upskirt',
  'urethra play',
  'urophilia',
  'vagina',
  'venus mound',
  'viagra',
  'vibrator',
  'violet wand',
  'vorarephilia',
  'voyeur',
  'voyeurweb',
  'voyuer',
  'vulva',
  'wank',
  'wetback',
  'wet dream',
  'white power',
  'whore',
  'worldsex',
  'wrapping men',
  'wrinkled starfish',
  'xx',
  'xxx',
  'yaoi',
  'yellow showers',
  'yiffy',
  'zoophilia',
];

/**
 * Set of profane words for efficient O(1) lookup
 * All words stored in lowercase for case-insensitive matching
 */
export const PROFANITY_SET = new Set(PROFANITY_WORDS.map((word) => word.toLowerCase()));

/**
 * Get the total number of profane words in the list
 */
export const getProfanityListSize = (): number => PROFANITY_SET.size;

Version 2 (latest)

'use strict';

/**
 * Profanity word list for content filtering
 *
 * Source: LDNOOBW (List of Dirty, Naughty, Obscene, and Otherwise Bad Words)
 * Repository: https://github.com/LDNOOBW/List-of-Dirty-Naughty-Obscene-and-Otherwise-Bad-Words
 * License: Public Domain / No explicit license (widely used in open source projects)
 * Last Updated: 2024
 *
 * This list contains English profanity and offensive terms.
 * Use responsibly and customize based on your application's needs.
 */

const PROFANITY_WORDS = [
  '2g1c',
  '2 girls 1 cup',
  'acrotomophilia',
  'alabama hot pocket',
  'alaskan pipeline',
  'anal',
  'anilingus',
  'anus',
  'apeshit',
  'arsehole',
  'ass',
  'asshole',
  'assmunch',
  'auto erotic',
  'autoerotic',
  'babeland',
  'baby batter',
  'baby juice',
  'ball gag',
  'ball gravy',
  'ball kicking',
  'ball licking',
  'ball sack',
  'ball sucking',
  'bangbros',
  'bangbus',
  'bareback',
  'barely legal',
  'barenaked',
  'bastard',
  'bastardo',
  'bastinado',
  'bbw',
  'bdsm',
  'beaner',
  'beaners',
  'beaver cleaver',
  'beaver lips',
  'beastiality',
  'bestiality',
  'big black',
  'big breasts',
  'big knockers',
  'big tits',
  'bimbos',
  'birdlock',
  'bitch',
  'bitches',
  'black cock',
  'blonde action',
  'blonde on blonde action',
  'blowjob',
  'blow job',
  'blow your load',
  'blue waffle',
  'blumpkin',
  'bollocks',
  'bondage',
  'boner',
  'boob',
  'boobs',
  'booty call',
  'brown showers',
  'brunette action',
  'bukkake',
  'bulldyke',
  'bullet vibe',
  'bullshit',
  'bung hole',
  'bunghole',
  'busty',
  'butt',
  'buttcheeks',
  'butthole',
  'camel toe',
  'camgirl',
  'camslut',
  'camwhore',
  'carpet muncher',
  'carpetmuncher',
  'chocolate rosebuds',
  'cialis',
  'circlejerk',
  'cleveland steamer',
  'clit',
  'clitoris',
  'clover clamps',
  'clusterfuck',
  'cock',
  'cocks',
  'coprolagnia',
  'coprophilia',
  'cornhole',
  'coon',
  'coons',
  'creampie',
  'cum',
  'cumming',
  'cumshot',
  'cumshots',
  'cunnilingus',
  'cunt',
  'darkie',
  'date rape',
  'daterape',
  'deep throat',
  'deepthroat',
  'dendrophilia',
  'dick',
  'dildo',
  'dingleberry',
  'dingleberries',
  'dirty pillows',
  'dirty sanchez',
  'doggie style',
  'doggiestyle',
  'doggy style',
  'doggystyle',
  'dog style',
  'dolcett',
  'domination',
  'dominatrix',
  'dommes',
  'donkey punch',
  'double dong',
  'double penetration',
  'dp action',
  'dry hump',
  'dvda',
  'eat my ass',
  'ecchi',
  'ejaculation',
  'erotic',
  'erotism',
  'escort',
  'eunuch',
  'fag',
  'faggot',
  'fecal',
  'felch',
  'fellatio',
  'feltch',
  'female squirting',
  'femdom',
  'figging',
  'fingerbang',
  'fingering',
  'fisting',
  'foot fetish',
  'footjob',
  'frotting',
  'fuck',
  'fuck buttons',
  'fuckin',
  'fucking',
  'fucktards',
  'fudge packer',
  'fudgepacker',
  'futanari',
  'gangbang',
  'gang bang',
  'gay sex',
  'genitals',
  'giant cock',
  'girl on',
  'girl on top',
  'girls gone wild',
  'goatcx',
  'goatse',
  'god damn',
  'gokkun',
  'golden shower',
  'goodpoop',
  'goo girl',
  'goregasm',
  'grope',
  'group sex',
  'g-spot',
  'guro',
  'hand job',
  'handjob',
  'hard core',
  'hardcore',
  'hentai',
  'homoerotic',
  'honkey',
  'hooker',
  'horny',
  'hot carl',
  'hot chick',
  'how to kill',
  'how to murder',
  'huge fat',
  'humping',
  'incest',
  'intercourse',
  'jack off',
  'jail bait',
  'jailbait',
  'jelly donut',
  'jerk off',
  'jigaboo',
  'jiggaboo',
  'jiggerboo',
  'jizz',
  'juggs',
  'kike',
  'kinbaku',
  'kinkster',
  'kinky',
  'knobbing',
  'leather restraint',
  'leather straight jacket',
  'lemon party',
  'livesex',
  'lolita',
  'lovemaking',
  'make me come',
  'male squirting',
  'masturbate',
  'masturbating',
  'masturbation',
  'menage a trois',
  'milf',
  'missionary position',
  'mong',
  'motherfucker',
  'mound of venus',
  'mr hands',
  'muff diver',
  'muffdiving',
  'nambla',
  'nawashi',
  'negro',
  'neonazi',
  'nigga',
  'nigger',
  'nig nog',
  'nimphomania',
  'nipple',
  'nipples',
  'nsfw',
  'nsfw images',
  'nude',
  'nudity',
  'nutten',
  'nympho',
  'nymphomania',
  'octopussy',
  'omorashi',
  'one cup two girls',
  'one guy one jar',
  'orgasm',
  'orgy',
  'paedophile',
  'paki',
  'panties',
  'panty',
  'pedobear',
  'pedophile',
  'pegging',
  'penis',
  'phone sex',
  'piece of shit',
  'pikey',
  'pissing',
  'piss pig',
  'pisspig',
  'playboy',
  'pleasure chest',
  'pole smoker',
  'ponyplay',
  'poof',
  'poon',
  'poontang',
  'punany',
  'poop chute',
  'poopchute',
  'porn',
  'porno',
  'pornography',
  'prince albert piercing',
  'pthc',
  'pubes',
  'pussy',
  'queaf',
  'queef',
  'quim',
  'raghead',
  'raging boner',
  'rape',
  'raping',
  'rapist',
  'rectum',
  'reverse cowgirl',
  'rimjob',
  'rimming',
  'rosy palm',
  'rosy palm and her 5 sisters',
  'rusty trombone',
  'sadism',
  'santorum',
  'scat',
  'schlong',
  'scissoring',
  'semen',
  'sex',
  'sexcam',
  'sexo',
  'sexy',
  'sexual',
  'sexually',
  'sexuality',
  'shaved beaver',
  'shaved pussy',
  'shemale',
  'shibari',
  'shit',
  'shitblimp',
  'shitty',
  'shota',
  'shrimping',
  'skeet',
  'slanteye',
  'slut',
  's&m',
  'smut',
  'snatch',
  'snowballing',
  'sodomize',
  'sodomy',
  'spastic',
  'spic',
  'splooge',
  'splooge moose',
  'spooge',
  'spread legs',
  'spunk',
  'strap on',
  'strapon',
  'strappado',
  'strip club',
  'style doggy',
  'suck',
  'sucks',
  'suicide girls',
  'sultry women',
  'swastika',
  'swinger',
  'tainted love',
  'taste my',
  'tea bagging',
  'threesome',
  'throating',
  'thumbzilla',
  'tied up',
  'tight white',
  'tit',
  'tits',
  'titties',
  'titty',
  'tongue in a',
  'topless',
  'tosser',
  'towelhead',
  'tranny',
  'tribadism',
  'tub girl',
  'tubgirl',
  'tushy',
  'twat',
  'twink',
  'twinkie',
  'two girls one cup',
  'undressing',
  'upskirt',
  'urethra play',
  'urophilia',
  'vagina',
  'venus mound',
  'viagra',
  'vibrator',
  'violet wand',
  'vorarephilia',
  'voyeur',
  'voyeurweb',
  'voyuer',
  'vulva',
  'wank',
  'wetback',
  'wet dream',
  'white power',
  'whore',
  'worldsex',
  'wrapping men',
  'wrinkled starfish',
  'xx',
  'xxx',
  'yaoi',
  'yellow showers',
  'yiffy',
  'zoophilia',
];

/**
 * Set of profane words for efficient O(1) lookup
 * All words stored in lowercase for case-insensitive matching
 */
export const PROFANITY_SET = new Set(PROFANITY_WORDS.map((word) => word.toLowerCase()));

/**
 * Get the total number of profane words in the list
 */
export const getProfanityListSize = (): number => PROFANITY_SET.size;

packages/cwc-utils/tsconfig.json

2 versions

Version 1

{
  "extends": "../../tsconfig.base.json",
  "compilerOptions": {
    "composite": true,
    "rootDir": "./src",
    "outDir": "./dist"
  },
  "include": ["src/**/*"]
}

Version 2 (latest)

{
  "extends": "../../tsconfig.base.json",
  "compilerOptions": {
    "composite": true,
    "rootDir": "./src",
    "outDir": "./dist"
  },
  "include": ["src/**/*"]
}

tsconfig.base.json

2 versions

Version 1

{
  "compilerOptions": {
    /* Language and Environment */
    "target": "ES2022",
    "lib": ["ES2022"],

    /* Modules */
    "module": "NodeNext",
    "moduleResolution": "NodeNext",
    "resolveJsonModule": true,

    /* Emit */
    "declaration": true,
    "declarationMap": true,
    "sourceMap": true,
    "outDir": "./dist",
    "removeComments": true,
    "incremental": true,

    /* Interop Constraints */
    "esModuleInterop": true,
    "allowSyntheticDefaultImports": true,
    "forceConsistentCasingInFileNames": true,
    "isolatedModules": true,

    /* Type Checking - STRICT MODE */
    "strict": true,
    "noUnusedLocals": true,
    "noUnusedParameters": true,
    "noImplicitReturns": true,
    "noFallthroughCasesInSwitch": true,
    "noUncheckedIndexedAccess": true,
    "exactOptionalPropertyTypes": true,
    "noImplicitOverride": true,
    "noPropertyAccessFromIndexSignature": true,

    /* Completeness */
    "skipLibCheck": true,

    /* Disallow JavaScript */
    "allowJs": false,
    "checkJs": false
  },
  "exclude": ["node_modules", "dist", "coverage", ".turbo"]
}

Version 2 (latest)

{
  "compilerOptions": {
    /* Language and Environment */
    "target": "ES2022",
    "lib": ["ES2022"],

    /* Modules */
    "module": "ES2022",
    "moduleResolution": "bundler",
    "resolveJsonModule": true,

    /* Emit */
    "declaration": true,
    "declarationMap": true,
    "sourceMap": true,
    "outDir": "./dist",
    "removeComments": true,
    "incremental": true,

    /* Interop Constraints */
    "esModuleInterop": true,
    "allowSyntheticDefaultImports": true,
    "forceConsistentCasingInFileNames": true,
    "isolatedModules": true,

    /* Type Checking - STRICT MODE */
    "strict": true,
    "noUnusedLocals": true,
    "noUnusedParameters": true,
    "noImplicitReturns": true,
    "noFallthroughCasesInSwitch": true,
    "noUncheckedIndexedAccess": true,
    "exactOptionalPropertyTypes": true,
    "noImplicitOverride": true,
    "noPropertyAccessFromIndexSignature": true,

    /* Completeness */
    "skipLibCheck": true,

    /* Disallow JavaScript */
    "allowJs": false,
    "checkJs": false
  },
  "exclude": ["node_modules", "dist", "coverage", ".turbo"]
}