@contractspec/example.saas-boilerplate 3.7.6 → 3.7.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contractspec/example.saas-boilerplate",
-  "version": "3.7.6",
+  "version": "3.7.7",
   "description": "SaaS Boilerplate - Users, Orgs, Projects, Billing, Settings",
   "type": "module",
   "types": "./dist/index.d.ts",
@@ -351,21 +351,21 @@
     "dev": "contractspec-bun-build dev",
     "clean": "rimraf dist .turbo",
     "lint": "bun lint:fix",
-    "lint:fix": "eslint src --fix",
-    "lint:check": "eslint src",
+    "lint:fix": "biome check --write --unsafe --only=nursery/useSortedClasses . && biome check --write .",
+    "lint:check": "biome check .",
     "test": "bun test --pass-with-no-tests",
     "prebuild": "contractspec-bun-build prebuild",
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
-    "@contractspec/lib.identity-rbac": "3.7.6",
-    "@contractspec/lib.jobs": "3.7.6",
-    "@contractspec/module.audit-trail": "3.7.6",
-    "@contractspec/module.notifications": "3.7.6",
-    "@contractspec/lib.contracts-spec": "3.7.6",
+    "@contractspec/lib.identity-rbac": "3.7.7",
+    "@contractspec/lib.jobs": "3.7.7",
+    "@contractspec/module.audit-trail": "3.7.7",
+    "@contractspec/module.notifications": "3.7.7",
+    "@contractspec/lib.contracts-spec": "4.0.0",
     "@contractspec/lib.schema": "3.7.6",
-    "@contractspec/lib.example-shared-ui": "6.0.6",
-    "@contractspec/lib.design-system": "3.7.6",
+    "@contractspec/lib.example-shared-ui": "6.0.7",
+    "@contractspec/lib.design-system": "3.8.0",
     "@contractspec/lib.runtime-sandbox": "2.7.6",
     "react": "19.2.0",
     "react-dom": "19.2.0"

package/src/billing/billing.entity.ts

@@ -1,158 +1,158 @@
 import {
-  defineEntity,
-  defineEntityEnum,
-  field,
-  index,
+	defineEntity,
+	defineEntityEnum,
+	field,
+	index,
 } from '@contractspec/lib.schema';
 
 /**
  * Subscription status enum for entities.
  */
 export const SubscriptionStatusEnum = defineEntityEnum({
-  name: 'SubscriptionStatus',
-  values: ['TRIALING', 'ACTIVE', 'PAST_DUE', 'CANCELED', 'PAUSED'] as const,
-  schema: 'saas_app',
-  description: 'Status of a subscription.',
+	name: 'SubscriptionStatus',
+	values: ['TRIALING', 'ACTIVE', 'PAST_DUE', 'CANCELED', 'PAUSED'] as const,
+	schema: 'saas_app',
+	description: 'Status of a subscription.',
 });
 
 /**
  * Subscription entity - organization subscription info.
  */
 export const SubscriptionEntity = defineEntity({
-  name: 'Subscription',
-  description: 'Organization subscription/plan information.',
-  schema: 'saas_app',
-  map: 'subscription',
-  fields: {
-    id: field.id(),
-    organizationId: field.foreignKey({ isUnique: true }),
-
-    // Plan info
-    planId: field.string({ description: 'Plan identifier' }),
-    planName: field.string({ description: 'Plan display name' }),
-
-    // Status
-    status: field.enum('SubscriptionStatus'),
-
-    // Billing cycle
-    currentPeriodStart: field.dateTime(),
-    currentPeriodEnd: field.dateTime(),
-
-    // Trial
-    trialEndsAt: field.dateTime({ isOptional: true }),
-
-    // Cancellation
-    cancelAtPeriodEnd: field.boolean({ default: false }),
-    canceledAt: field.dateTime({ isOptional: true }),
-
-    // External reference
-    stripeSubscriptionId: field.string({ isOptional: true }),
-    stripeCustomerId: field.string({ isOptional: true }),
-
-    // Metadata
-    metadata: field.json({ isOptional: true }),
-
-    // Timestamps
-    createdAt: field.createdAt(),
-    updatedAt: field.updatedAt(),
-  },
-  enums: [SubscriptionStatusEnum],
+	name: 'Subscription',
+	description: 'Organization subscription/plan information.',
+	schema: 'saas_app',
+	map: 'subscription',
+	fields: {
+		id: field.id(),
+		organizationId: field.foreignKey({ isUnique: true }),
+
+		// Plan info
+		planId: field.string({ description: 'Plan identifier' }),
+		planName: field.string({ description: 'Plan display name' }),
+
+		// Status
+		status: field.enum('SubscriptionStatus'),
+
+		// Billing cycle
+		currentPeriodStart: field.dateTime(),
+		currentPeriodEnd: field.dateTime(),
+
+		// Trial
+		trialEndsAt: field.dateTime({ isOptional: true }),
+
+		// Cancellation
+		cancelAtPeriodEnd: field.boolean({ default: false }),
+		canceledAt: field.dateTime({ isOptional: true }),
+
+		// External reference
+		stripeSubscriptionId: field.string({ isOptional: true }),
+		stripeCustomerId: field.string({ isOptional: true }),
+
+		// Metadata
+		metadata: field.json({ isOptional: true }),
+
+		// Timestamps
+		createdAt: field.createdAt(),
+		updatedAt: field.updatedAt(),
+	},
+	enums: [SubscriptionStatusEnum],
 });
 
 /**
  * BillingUsage entity - track feature usage.
  */
 export const BillingUsageEntity = defineEntity({
-  name: 'BillingUsage',
-  description: 'Track usage of metered features.',
-  schema: 'saas_app',
-  map: 'billing_usage',
-  fields: {
-    id: field.id(),
-    organizationId: field.foreignKey(),
-
-    // Feature
-    feature: field.string({
-      description: 'Feature being tracked (e.g., "api_calls", "storage_gb")',
-    }),
-
-    // Usage
-    quantity: field.int({ description: 'Usage quantity' }),
-    unit: field.string({
-      isOptional: true,
-      description: 'Unit of measurement',
-    }),
-
-    // Period
-    billingPeriod: field.string({
-      description: 'Billing period (e.g., "2024-01")',
-    }),
-
-    // Aggregation
-    recordedAt: field.dateTime({ description: 'When usage was recorded' }),
-
-    // Source
-    sourceId: field.string({
-      isOptional: true,
-      description: 'Source of usage (e.g., request ID)',
-    }),
-    sourceType: field.string({ isOptional: true }),
-
-    // Metadata
-    metadata: field.json({ isOptional: true }),
-  },
-  indexes: [
-    index.on(['organizationId', 'feature', 'billingPeriod']),
-    index.on(['organizationId', 'recordedAt']),
-  ],
+	name: 'BillingUsage',
+	description: 'Track usage of metered features.',
+	schema: 'saas_app',
+	map: 'billing_usage',
+	fields: {
+		id: field.id(),
+		organizationId: field.foreignKey(),
+
+		// Feature
+		feature: field.string({
+			description: 'Feature being tracked (e.g., "api_calls", "storage_gb")',
+		}),
+
+		// Usage
+		quantity: field.int({ description: 'Usage quantity' }),
+		unit: field.string({
+			isOptional: true,
+			description: 'Unit of measurement',
+		}),
+
+		// Period
+		billingPeriod: field.string({
+			description: 'Billing period (e.g., "2024-01")',
+		}),
+
+		// Aggregation
+		recordedAt: field.dateTime({ description: 'When usage was recorded' }),
+
+		// Source
+		sourceId: field.string({
+			isOptional: true,
+			description: 'Source of usage (e.g., request ID)',
+		}),
+		sourceType: field.string({ isOptional: true }),
+
+		// Metadata
+		metadata: field.json({ isOptional: true }),
+	},
+	indexes: [
+		index.on(['organizationId', 'feature', 'billingPeriod']),
+		index.on(['organizationId', 'recordedAt']),
+	],
 });
 
 /**
  * UsageLimit entity - feature usage limits per plan.
  */
 export const UsageLimitEntity = defineEntity({
-  name: 'UsageLimit',
-  description: 'Usage limits per plan/organization.',
-  schema: 'saas_app',
-  map: 'usage_limit',
-  fields: {
-    id: field.id(),
-
-    // Scope
-    planId: field.string({
-      isOptional: true,
-      description: 'Plan this limit applies to',
-    }),
-    organizationId: field.string({
-      isOptional: true,
-      description: 'Org-specific override',
-    }),
-
-    // Limit
-    feature: field.string({ description: 'Feature being limited' }),
-    limit: field.int({ description: 'Maximum allowed usage' }),
-    resetPeriod: field.string({
-      default: '"monthly"',
-      description: 'When limit resets',
-    }),
-
-    // Soft/hard limit
-    isSoftLimit: field.boolean({
-      default: false,
-      description: 'Whether to warn vs block',
-    }),
-    overage: field.boolean({
-      default: false,
-      description: 'Whether overage is allowed',
-    }),
-    overageRate: field.float({
-      isOptional: true,
-      description: 'Cost per unit over limit',
-    }),
-
-    // Timestamps
-    createdAt: field.createdAt(),
-    updatedAt: field.updatedAt(),
-  },
-  indexes: [index.unique(['planId', 'feature'])],
+	name: 'UsageLimit',
+	description: 'Usage limits per plan/organization.',
+	schema: 'saas_app',
+	map: 'usage_limit',
+	fields: {
+		id: field.id(),
+
+		// Scope
+		planId: field.string({
+			isOptional: true,
+			description: 'Plan this limit applies to',
+		}),
+		organizationId: field.string({
+			isOptional: true,
+			description: 'Org-specific override',
+		}),
+
+		// Limit
+		feature: field.string({ description: 'Feature being limited' }),
+		limit: field.int({ description: 'Maximum allowed usage' }),
+		resetPeriod: field.string({
+			default: '"monthly"',
+			description: 'When limit resets',
+		}),
+
+		// Soft/hard limit
+		isSoftLimit: field.boolean({
+			default: false,
+			description: 'Whether to warn vs block',
+		}),
+		overage: field.boolean({
+			default: false,
+			description: 'Whether overage is allowed',
+		}),
+		overageRate: field.float({
+			isOptional: true,
+			description: 'Cost per unit over limit',
+		}),
+
+		// Timestamps
+		createdAt: field.createdAt(),
+		updatedAt: field.updatedAt(),
+	},
+	indexes: [index.unique(['planId', 'feature'])],
 });

package/src/billing/billing.enum.ts

@@ -5,19 +5,19 @@ import { defineEnum } from '@contractspec/lib.schema';
  * Note: Entity enum is defined separately in billing.entity.ts
  */
 export const SubscriptionStatusSchemaEnum = defineEnum('SubscriptionStatus', [
-  'TRIALING',
-  'ACTIVE',
-  'PAST_DUE',
-  'CANCELED',
-  'PAUSED',
+	'TRIALING',
+	'ACTIVE',
+	'PAST_DUE',
+	'CANCELED',
+	'PAUSED',
 ]);
 
 /**
  * Feature access reason enum.
  */
 export const FeatureAccessReasonEnum = defineEnum('FeatureAccessReason', [
-  'included',
-  'limit_available',
-  'limit_reached',
-  'not_in_plan',
+	'included',
+	'limit_available',
+	'limit_reached',
+	'not_in_plan',
 ]);

package/src/billing/billing.event.ts

@@ -1,108 +1,108 @@
-import { ScalarTypeEnum, defineSchemaModel } from '@contractspec/lib.schema';
 import { defineEvent } from '@contractspec/lib.contracts-spec';
+import { defineSchemaModel, ScalarTypeEnum } from '@contractspec/lib.schema';
 
 /**
  * Payload when feature usage is recorded.
  */
 const UsageRecordedPayload = defineSchemaModel({
-  name: 'UsageRecordedPayload',
-  description: 'Payload when feature usage is recorded',
-  fields: {
-    organizationId: {
-      type: ScalarTypeEnum.String_unsecure(),
-      isOptional: false,
-    },
-    feature: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
-    quantity: { type: ScalarTypeEnum.Int_unsecure(), isOptional: false },
-    billingPeriod: {
-      type: ScalarTypeEnum.String_unsecure(),
-      isOptional: false,
-    },
-    recordedAt: { type: ScalarTypeEnum.DateTime(), isOptional: false },
-  },
+	name: 'UsageRecordedPayload',
+	description: 'Payload when feature usage is recorded',
+	fields: {
+		organizationId: {
+			type: ScalarTypeEnum.String_unsecure(),
+			isOptional: false,
+		},
+		feature: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+		quantity: { type: ScalarTypeEnum.Int_unsecure(), isOptional: false },
+		billingPeriod: {
+			type: ScalarTypeEnum.String_unsecure(),
+			isOptional: false,
+		},
+		recordedAt: { type: ScalarTypeEnum.DateTime(), isOptional: false },
+	},
 });
 
 /**
  * Payload when usage limit is reached.
  */
 const UsageLimitReachedPayload = defineSchemaModel({
-  name: 'UsageLimitReachedPayload',
-  description: 'Payload when usage limit is reached',
-  fields: {
-    organizationId: {
-      type: ScalarTypeEnum.String_unsecure(),
-      isOptional: false,
-    },
-    feature: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
-    limit: { type: ScalarTypeEnum.Int_unsecure(), isOptional: false },
-    currentUsage: { type: ScalarTypeEnum.Int_unsecure(), isOptional: false },
-    reachedAt: { type: ScalarTypeEnum.DateTime(), isOptional: false },
-  },
+	name: 'UsageLimitReachedPayload',
+	description: 'Payload when usage limit is reached',
+	fields: {
+		organizationId: {
+			type: ScalarTypeEnum.String_unsecure(),
+			isOptional: false,
+		},
+		feature: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+		limit: { type: ScalarTypeEnum.Int_unsecure(), isOptional: false },
+		currentUsage: { type: ScalarTypeEnum.Int_unsecure(), isOptional: false },
+		reachedAt: { type: ScalarTypeEnum.DateTime(), isOptional: false },
+	},
 });
 
 /**
  * Payload when subscription status changes.
  */
 const SubscriptionChangedPayload = defineSchemaModel({
-  name: 'SubscriptionChangedPayload',
-  description: 'Payload when subscription status changes',
-  fields: {
-    organizationId: {
-      type: ScalarTypeEnum.String_unsecure(),
-      isOptional: false,
-    },
-    previousPlan: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
-    newPlan: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
-    previousStatus: {
-      type: ScalarTypeEnum.String_unsecure(),
-      isOptional: true,
-    },
-    newStatus: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
-    changedAt: { type: ScalarTypeEnum.DateTime(), isOptional: false },
-  },
+	name: 'SubscriptionChangedPayload',
+	description: 'Payload when subscription status changes',
+	fields: {
+		organizationId: {
+			type: ScalarTypeEnum.String_unsecure(),
+			isOptional: false,
+		},
+		previousPlan: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+		newPlan: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+		previousStatus: {
+			type: ScalarTypeEnum.String_unsecure(),
+			isOptional: true,
+		},
+		newStatus: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+		changedAt: { type: ScalarTypeEnum.DateTime(), isOptional: false },
+	},
 });
 
 /**
  * Event: Feature usage has been recorded.
  */
 export const UsageRecordedEvent = defineEvent({
-  meta: {
-    key: 'billing.usage.recorded',
-    version: '1.0.0',
-    description: 'Feature usage has been recorded.',
-    stability: 'stable',
-    owners: ['@saas-team'],
-    tags: ['billing', 'usage', 'recorded'],
-  },
-  payload: UsageRecordedPayload,
+	meta: {
+		key: 'billing.usage.recorded',
+		version: '1.0.0',
+		description: 'Feature usage has been recorded.',
+		stability: 'stable',
+		owners: ['@saas-team'],
+		tags: ['billing', 'usage', 'recorded'],
+	},
+	payload: UsageRecordedPayload,
 });
 
 /**
  * Event: Usage limit has been reached for a feature.
  */
 export const UsageLimitReachedEvent = defineEvent({
-  meta: {
-    key: 'billing.limit.reached',
-    version: '1.0.0',
-    description: 'Usage limit has been reached for a feature.',
-    stability: 'stable',
-    owners: ['@saas-team'],
-    tags: ['billing', 'limit', 'reached'],
-  },
-  payload: UsageLimitReachedPayload,
+	meta: {
+		key: 'billing.limit.reached',
+		version: '1.0.0',
+		description: 'Usage limit has been reached for a feature.',
+		stability: 'stable',
+		owners: ['@saas-team'],
+		tags: ['billing', 'limit', 'reached'],
+	},
+	payload: UsageLimitReachedPayload,
 });
 
 /**
  * Event: Subscription status has changed.
  */
 export const SubscriptionChangedEvent = defineEvent({
-  meta: {
-    key: 'billing.subscription.changed',
-    version: '1.0.0',
-    description: 'Subscription status has changed.',
-    stability: 'stable',
-    owners: ['@saas-team'],
-    tags: ['billing', 'subscription', 'changed'],
-  },
-  payload: SubscriptionChangedPayload,
+	meta: {
+		key: 'billing.subscription.changed',
+		version: '1.0.0',
+		description: 'Subscription status has changed.',
+		stability: 'stable',
+		owners: ['@saas-team'],
+		tags: ['billing', 'subscription', 'changed'],
+	},
+	payload: SubscriptionChangedPayload,
 });