schemock 0.0.3-alpha.1 → 0.0.4-alpha.2

package/README.md

@@ -652,6 +652,104 @@ npx schemock generate --exclude audit,log
 
 **Note:** Types always include all entities to preserve relations (e.g., `User.posts`). Only CRUD operations/routes are filtered.
 
+### Entity Tagging
+
+Tags provide flexible, freeform categorization for filtering entities across targets. Unlike `entities`/`excludeEntities` which use explicit names, tags let you organize schemas by domain, access level, or any custom taxonomy.
+
+**Adding tags to schemas:**
+
+```typescript
+const User = defineData('user', {
+  id: field.uuid(),
+  email: field.email(),
+}, {
+  tags: ['auth', 'public', 'core'],
+  module: 'identity',
+  group: 'public',
+});
+
+const AuditLog = defineData('auditLog', {
+  id: field.uuid(),
+  action: field.string(),
+}, {
+  tags: ['internal', 'compliance'],
+  module: 'security',
+  group: 'internal',
+});
+```
+
+**Filtering by tags in targets:**
+
+```typescript
+targets: [
+  {
+    name: 'public-api',
+    type: 'nextjs-api',
+    output: './src/app/api/public',
+    tags: ['public'],           // Include entities with 'public' tag
+    excludeTags: ['internal'],  // Exclude entities with 'internal' tag
+  },
+  {
+    name: 'admin-dashboard',
+    type: 'mock',
+    output: './src/generated/admin',
+    module: 'security',         // Only entities in 'security' module
+  },
+  {
+    name: 'auth-service',
+    type: 'node-handlers',
+    output: './src/auth/handlers',
+    tags: ['auth'],
+    group: 'public',
+  },
+]
+```
+
+#### Common Tagging Patterns
+
+Tags are freeform strings - use whatever fits your project. Here are patterns others find useful:
+
+**By access level:**
+```typescript
+tags: ['public']      // Exposed to external clients
+tags: ['internal']    // Internal services only
+tags: ['admin-only']  // Admin dashboard only
+```
+
+**By feature area:**
+```typescript
+tags: ['auth']        // Authentication/authorization
+tags: ['billing']     // Payment and subscriptions
+tags: ['content']     // User-generated content
+tags: ['analytics']   // Metrics and reporting
+```
+
+**By lifecycle:**
+```typescript
+tags: ['stable']       // Production-ready
+tags: ['experimental'] // Beta features
+tags: ['deprecated']   // Scheduled for removal
+```
+
+**By team ownership:**
+```typescript
+tags: ['team-platform']  // Platform team owns this
+tags: ['team-growth']    // Growth team owns this
+```
+
+**Combined example:**
+```typescript
+const Payment = defineData('payment', { /* ... */ }, {
+  tags: ['billing', 'internal', 'stable'],
+  module: 'billing',
+  group: 'internal',
+  metadata: {
+    owner: 'payments-team',
+    pii: true,
+  },
+});
+```
+
 ### Generated Server Files
 
 **Next.js API Routes** (`nextjs-api` target):

package/dist/adapters/index.d.mts

@@ -1,7 +1,7 @@
-import { A as Adapter, a as AdapterContext, b as AdapterResponse, d as MswjsDataFactory, F as FetchAdapterOptions } from '../types-C9VMgu3E.mjs';
-export { c as AdapterResponseMeta, D as Database, M as MockAdapterOptions, S as SchemaRegistry } from '../types-C9VMgu3E.mjs';
-import { o as EntitySchema, b as FieldDefinition } from '../types-C2bd2vgy.mjs';
-import { M as Middleware } from '../types-DV2DS7wj.mjs';
+import { A as Adapter, a as AdapterContext, b as AdapterResponse, d as MswjsDataFactory, F as FetchAdapterOptions } from '../types-vPJ91BuY.mjs';
+export { c as AdapterResponseMeta, D as Database, M as MockAdapterOptions, S as SchemaRegistry } from '../types-vPJ91BuY.mjs';
+import { o as EntitySchema, b as FieldDefinition } from '../types-CWZQ6vqt.mjs';
+import { M as Middleware } from '../types-D-u5uw1E.mjs';
 
 /**
  * Storage Driver Types - Abstract storage interface for different backends

package/dist/adapters/index.d.ts

@@ -1,7 +1,7 @@
-import { A as Adapter, a as AdapterContext, b as AdapterResponse, d as MswjsDataFactory, F as FetchAdapterOptions } from '../types-c2AN3vky.js';
-export { c as AdapterResponseMeta, D as Database, M as MockAdapterOptions, S as SchemaRegistry } from '../types-c2AN3vky.js';
-import { o as EntitySchema, b as FieldDefinition } from '../types-C2bd2vgy.js';
-import { M as Middleware } from '../types-C1MiZh1d.js';
+import { A as Adapter, a as AdapterContext, b as AdapterResponse, d as MswjsDataFactory, F as FetchAdapterOptions } from '../types-4EDTne0h.js';
+export { c as AdapterResponseMeta, D as Database, M as MockAdapterOptions, S as SchemaRegistry } from '../types-4EDTne0h.js';
+import { o as EntitySchema, b as FieldDefinition } from '../types-CWZQ6vqt.js';
+import { M as Middleware } from '../types-Ku_ykMzx.js';
 
 /**
  * Storage Driver Types - Abstract storage interface for different backends

package/dist/cli/index.d.mts

@@ -1,5 +1,5 @@
-import { l as RLSScopeMapping, m as RLSBypass, n as RLSConfig, o as EntitySchema, v as EndpointSchema, b as FieldDefinition } from '../types-C2bd2vgy.mjs';
-export { I as IndexConfig, j as RLSContext, k as RLSFilter, f as RPCArgument, g as RPCConfig } from '../types-C2bd2vgy.mjs';
+import { l as RLSScopeMapping, m as RLSBypass, n as RLSConfig, o as EntitySchema, v as EndpointSchema, b as FieldDefinition } from '../types-CWZQ6vqt.mjs';
+export { I as IndexConfig, j as RLSContext, k as RLSFilter, f as RPCArgument, g as RPCConfig } from '../types-CWZQ6vqt.mjs';
 
 /**
  * CLI type definitions for Schemock code generation
@@ -134,6 +134,14 @@ interface GenerationTarget {
     entities?: string[];
     /** Which entities to exclude */
     excludeEntities?: string[];
+    /** Include only entities with these tags (OR logic - entity must have at least one) */
+    tags?: string[];
+    /** Exclude entities with these tags */
+    excludeTags?: string[];
+    /** Include only entities from this module */
+    module?: string;
+    /** Include only entities from this group */
+    group?: string;
     /** Backend to use for server targets (e.g., nextjs-api uses supabase under the hood) */
     backend?: 'supabase' | 'firebase' | 'pglite' | 'fetch';
     /** Middleware configuration for this target */
@@ -362,6 +370,14 @@ interface AnalyzedSchema {
     rls: AnalyzedRLS;
     indexes: AnalyzedIndex[];
     rpc: AnalyzedRPC[];
+    /** Tags for entity classification and filtering */
+    tags: string[];
+    /** Module/domain grouping */
+    module?: string;
+    /** Logical grouping (e.g., access level) */
+    group?: string;
+    /** Extensible metadata */
+    metadata?: Record<string, unknown>;
     original: EntitySchema;
 }
 /**

package/dist/cli/index.d.ts

@@ -1,5 +1,5 @@
-import { l as RLSScopeMapping, m as RLSBypass, n as RLSConfig, o as EntitySchema, v as EndpointSchema, b as FieldDefinition } from '../types-C2bd2vgy.js';
-export { I as IndexConfig, j as RLSContext, k as RLSFilter, f as RPCArgument, g as RPCConfig } from '../types-C2bd2vgy.js';
+import { l as RLSScopeMapping, m as RLSBypass, n as RLSConfig, o as EntitySchema, v as EndpointSchema, b as FieldDefinition } from '../types-CWZQ6vqt.js';
+export { I as IndexConfig, j as RLSContext, k as RLSFilter, f as RPCArgument, g as RPCConfig } from '../types-CWZQ6vqt.js';
 
 /**
  * CLI type definitions for Schemock code generation
@@ -134,6 +134,14 @@ interface GenerationTarget {
     entities?: string[];
     /** Which entities to exclude */
     excludeEntities?: string[];
+    /** Include only entities with these tags (OR logic - entity must have at least one) */
+    tags?: string[];
+    /** Exclude entities with these tags */
+    excludeTags?: string[];
+    /** Include only entities from this module */
+    module?: string;
+    /** Include only entities from this group */
+    group?: string;
     /** Backend to use for server targets (e.g., nextjs-api uses supabase under the hood) */
     backend?: 'supabase' | 'firebase' | 'pglite' | 'fetch';
     /** Middleware configuration for this target */
@@ -362,6 +370,14 @@ interface AnalyzedSchema {
     rls: AnalyzedRLS;
     indexes: AnalyzedIndex[];
     rpc: AnalyzedRPC[];
+    /** Tags for entity classification and filtering */
+    tags: string[];
+    /** Module/domain grouping */
+    module?: string;
+    /** Logical grouping (e.g., access level) */
+    group?: string;
+    /** Extensible metadata */
+    metadata?: Record<string, unknown>;
     original: EntitySchema;
 }
 /**

package/dist/cli/index.js

@@ -90,6 +90,11 @@ var GenerationTargetSchema = zod.z.object({
   output: zod.z.string().min(1, "target output path is required"),
   entities: zod.z.array(zod.z.string()).optional(),
   excludeEntities: zod.z.array(zod.z.string()).optional(),
+  // Tag-based filtering
+  tags: zod.z.array(zod.z.string()).optional(),
+  excludeTags: zod.z.array(zod.z.string()).optional(),
+  module: zod.z.string().optional(),
+  group: zod.z.string().optional(),
   backend: zod.z.enum(["supabase", "firebase", "pglite", "fetch"]).optional(),
   middleware: TargetMiddlewareConfigSchema.optional(),
   hooks: zod.z.string().optional(),
@@ -475,6 +480,12 @@ function toCamelCase(str) {
 function toSnakeCase(str) {
   return str.replace(/([A-Z])/g, "_$1").toLowerCase().replace(/^_/, "").replace(/[-\s]+/g, "_");
 }
+function toSafePropertyName(str) {
+  if (/^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(str)) {
+    return str;
+  }
+  return toCamelCase(str);
+}
 
 // src/cli/utils/faker-mapping.ts
 function escapeJsString(value) {
@@ -826,6 +837,11 @@ function analyzeSchema(schema, schemaMap, config) {
     // Will be populated after fields analysis
     rpc: [],
     // Will be populated after RPC analysis
+    // Entity Organization & Tagging
+    tags: schema.tags ?? [],
+    module: schema.module,
+    group: schema.group,
+    metadata: schema.metadata,
     original: schema
   };
   let refCount = 0;
@@ -1241,11 +1257,12 @@ function deriveEndpointName(path) {
   const parts = cleaned.split("/");
   const nameParts = [];
   for (let i = 0; i < parts.length; i++) {
-    const part = parts[i];
+    let part = parts[i];
     if (part.startsWith(":")) {
-      const paramName = part.slice(1);
+      const paramName = toCamelCaseFromHyphen(part.slice(1));
       nameParts.push("By" + capitalize(paramName));
     } else if (part) {
+      part = toCamelCaseFromHyphen(part);
       if (i === 0) {
         nameParts.push(part);
       } else {
@@ -1265,6 +1282,9 @@ function toPascalCase2(str) {
 function capitalize(str) {
   return str.charAt(0).toUpperCase() + str.slice(1);
 }
+function toCamelCaseFromHyphen(str) {
+  return str.split("-").map((part, index) => index === 0 ? part : capitalize(part)).join("");
+}
 function analyzeFields(fields) {
   return Object.entries(fields).map(([name, field]) => analyzeField2(name, field));
 }
@@ -1577,7 +1597,7 @@ function generateCommonTypes(code) {
 // src/cli/generators/mock/db.ts
 function generateMockDb(schemas, config) {
   const code = new CodeBuilder();
-  const entityNames = schemas.map((s) => s.name);
+  const entityNames = schemas.map((s) => toSafePropertyName(s.name));
   const persist = config.persist !== false;
   code.comment("GENERATED BY SCHEMOCK - DO NOT EDIT");
   code.line("import { factory, primaryKey, nullable } from '@mswjs/data';");
@@ -1733,7 +1753,8 @@ function generatePersistenceLayer(code, entityNames, storageKey) {
   code.line("wrapDbMethods();");
 }
 function generateEntityFactory(code, schema) {
-  code.block(`${schema.name}: {`, () => {
+  const safeName = toSafePropertyName(schema.name);
+  code.block(`${safeName}: {`, () => {
     for (const field of schema.fields) {
       if (field.name === "id") {
         code.line("id: primaryKey(faker.string.uuid),");
@@ -2455,15 +2476,17 @@ function generateSeed(schemas, config) {
   code.block("export interface SeedCounts {", () => {
     for (const schema of schemas) {
       if (schema.isJunctionTable) continue;
-      code.line(`${schema.name}?: number;`);
+      const safeName = toSafePropertyName(schema.name);
+      code.line(`${safeName}?: number;`);
     }
   });
   code.line();
   code.block("const defaultCounts: Required<SeedCounts> = {", () => {
     for (const schema of schemas) {
       if (schema.isJunctionTable) continue;
+      const safeName = toSafePropertyName(schema.name);
       const count = config.seed?.[schema.name] ?? 10;
-      code.line(`${schema.name}: ${count},`);
+      code.line(`${safeName}: ${count},`);
     }
   }, "};");
   code.line();
@@ -2480,16 +2503,17 @@ function generateSeed(schemas, config) {
     code.line();
     for (const schema of schemas) {
       if (schema.isJunctionTable) continue;
+      const safeName = toSafePropertyName(schema.name);
       const belongsToRels = schema.relations.filter((r) => r.type === "belongsTo");
       const fkFields = belongsToRels.map((r) => ({
         fieldName: r.localField || r.foreignKey,
-        target: r.target,
+        target: toSafePropertyName(r.target),
         nullable: schema.fields.find((f) => f.name === (r.localField || r.foreignKey))?.nullable ?? false
       }));
-      code.line(`ids.${schema.name} = [];`);
-      code.block(`for (let i = 0; i < merged.${schema.name}; i++) {`, () => {
+      code.line(`ids.${safeName} = [];`);
+      code.block(`for (let i = 0; i < merged.${safeName}; i++) {`, () => {
         if (fkFields.length > 0) {
-          code.line(`const item = db.${schema.name}.create({`);
+          code.line(`const item = db.${safeName}.create({`);
           code.indent();
           for (const fk of fkFields) {
             if (fk.nullable) {
@@ -2502,9 +2526,9 @@ function generateSeed(schemas, config) {
           code.line(`// eslint-disable-next-line @typescript-eslint/no-explicit-any`);
           code.line("} as any);");
         } else {
-          code.line(`const item = db.${schema.name}.create({});`);
+          code.line(`const item = db.${safeName}.create({});`);
         }
-        code.line(`ids.${schema.name}.push(item.id);`);
+        code.line(`ids.${safeName}.push(item.id);`);
       });
       code.line();
     }
@@ -2512,14 +2536,16 @@ function generateSeed(schemas, config) {
   code.line();
   code.block("export function reset(): void {", () => {
     for (const schema of [...schemas].reverse()) {
-      code.line(`db.${schema.name}.deleteMany({ where: {} });`);
+      const safeName = toSafePropertyName(schema.name);
+      code.line(`db.${safeName}.deleteMany({ where: {} });`);
     }
   });
   code.line();
   code.block("export function getAll(): Record<string, unknown[]> {", () => {
     code.block("return {", () => {
       for (const schema of schemas) {
-        code.line(`${schema.name}: db.${schema.name}.getAll(),`);
+        const safeName = toSafePropertyName(schema.name);
+        code.line(`${safeName}: db.${safeName}.getAll(),`);
       }
     }, "};");
   });
@@ -5934,6 +5960,32 @@ function filterSchemasForTarget(schemas, target) {
       (s) => !excludeSet.has(s.name.toLowerCase()) && !excludeSet.has(s.pascalName.toLowerCase()) && !excludeSet.has(s.singularName.toLowerCase())
     );
   }
+  if (target.tags && target.tags.length > 0) {
+    const includeTags = new Set(target.tags.map((t) => t.toLowerCase()));
+    filtered = filtered.filter((s) => {
+      if (!s.tags || s.tags.length === 0) return false;
+      return s.tags.some((tag) => includeTags.has(tag.toLowerCase()));
+    });
+  }
+  if (target.excludeTags && target.excludeTags.length > 0) {
+    const excludeTags = new Set(target.excludeTags.map((t) => t.toLowerCase()));
+    filtered = filtered.filter((s) => {
+      if (!s.tags || s.tags.length === 0) return true;
+      return !s.tags.some((tag) => excludeTags.has(tag.toLowerCase()));
+    });
+  }
+  if (target.module) {
+    const targetModule = target.module.toLowerCase();
+    filtered = filtered.filter(
+      (s) => s.module && s.module.toLowerCase() === targetModule
+    );
+  }
+  if (target.group) {
+    const targetGroup = target.group.toLowerCase();
+    filtered = filtered.filter(
+      (s) => s.group && s.group.toLowerCase() === targetGroup
+    );
+  }
   return filtered;
 }
 function isServerTarget(type) {