@gzl10/nexus-sdk 0.3.0 → 0.4.1

package/dist/index.d.ts

@@ -11,11 +11,29 @@ import { Logger } from 'pino';
  * que pueden ser escritos a archivos o usados en runtime.
  */
 
+/** Directorio estándar para código generado */
+declare const GENERATED_DIR = "__generated__";
 /**
- * Entidades que persisten en BD local
- * Excluye: action, external, virtual, computed
+ * Entidades que persisten en BD local con tabla propia
+ * Excluye: action, external, virtual, computed, single (usa tabla compartida)
  */
-type PersistentEntityDefinition = CollectionEntityDefinition | SingleEntityDefinition | ReferenceEntityDefinition | EventEntityDefinition | ConfigEntityDefinition | TempEntityDefinition | ViewEntityDefinition;
+type PersistentEntityDefinition = CollectionEntityDefinition | ReferenceEntityDefinition | EventEntityDefinition | ConfigEntityDefinition | TempEntityDefinition | ViewEntityDefinition;
+/**
+ * Entidades sin persistencia local (read-only o sin BD)
+ */
+type NonPersistentEntityDefinition = ActionEntityDefinition | ExternalEntityDefinition | VirtualEntityDefinition | ComputedEntityDefinition;
+/**
+ * Type guard para verificar si una entidad persiste en BD local con tabla propia
+ */
+declare function isPersistentEntity(entity: EntityDefinition): entity is PersistentEntityDefinition;
+/**
+ * Type guard para verificar si es un singleton (usa tabla compartida sys_settings)
+ */
+declare function isSingletonEntity(entity: EntityDefinition): entity is SingleEntityDefinition;
+/**
+ * Type guard para verificar si una entidad tiene tabla propia (para migraciones)
+ */
+declare function hasTable(entity: EntityDefinition): entity is PersistentEntityDefinition;
 /**
  * Genera código de migración Knex desde EntityDefinition
  *
@@ -51,6 +69,15 @@ declare function generateZodSchema(entity: PersistentEntityDefinition): string;
  * // }
  */
 declare function generateModel(entity: PersistentEntityDefinition): string;
+/**
+ * Genera schema Zod para entidades read-only
+ * Solo genera el schema de output, no create/update
+ */
+declare function generateReadOnlySchema(entity: ComputedEntityDefinition | ExternalEntityDefinition | VirtualEntityDefinition): string;
+/**
+ * Genera interface TypeScript para entidades read-only
+ */
+declare function generateReadOnlyModel(entity: ComputedEntityDefinition | ExternalEntityDefinition | VirtualEntityDefinition): string;
 /**
  * Estructura de permiso generado para insertar en BD
  */
@@ -82,6 +109,38 @@ declare function generateCaslSeed(entities: EntityDefinition[]): string;
  * Obtiene el subject CASL de una entidad
  */
 declare function getEntitySubject(entity: PersistentEntityDefinition): string;
+/**
+ * Obtiene el nombre de una entidad en PascalCase singular
+ * 'cms_posts' → 'Post', 'rol_role_permissions' → 'RolePermission'
+ */
+declare function getEntityName(entity: EntityDefinition): string;
+/**
+ * Genera archivo completo de schemas Zod para múltiples entidades
+ * Consolida todas las entidades de un módulo en un solo archivo
+ *
+ * @example
+ * const code = generateSchemasFile([userEntity, roleEntity])
+ * writeFileSync('users.schemas.ts', code)
+ */
+declare function generateSchemasFile(definitions: EntityDefinition[]): string;
+/**
+ * Genera archivo completo de modelos TypeScript para múltiples entidades
+ * Consolida todas las entidades de un módulo en un solo archivo
+ *
+ * @example
+ * const code = generateModelsFile([userEntity, roleEntity])
+ * writeFileSync('users.models.ts', code)
+ */
+declare function generateModelsFile(definitions: EntityDefinition[]): string;
+/**
+ * Genera archivo completo de migración Knex para múltiples entidades
+ * Consolida todas las entidades de un módulo en un solo archivo de migración
+ *
+ * @example
+ * const code = generateMigrationsFile([userEntity, roleEntity])
+ * writeFileSync('users.migrate.ts', code)
+ */
+declare function generateMigrationsFile(definitions: EntityDefinition[]): string;
 
 /**
  * @gzl10/nexus-sdk
@@ -370,14 +429,24 @@ interface CollectionEntityDefinition extends BaseEntityDefinition {
     indexes?: EntityIndex[];
 }
 /**
- * Entidad singleton - Solo Update/Read, sin lista (site_config)
+ * Entidad singleton - Un solo registro en tabla compartida sys_settings
+ * Usa key-value: key identifica el registro, value es JSON con la estructura de fields
+ *
+ * @example
+ * // site_config singleton
+ * { type: 'single', key: 'site_config', label: 'Site Config', fields: { siteName: {...}, logo: {...} } }
+ * // Se guarda en sys_settings como: { key: 'site_config', value: { siteName: 'Mi App', logo: '...' } }
  */
-interface SingleEntityDefinition extends BaseEntityDefinition {
+interface SingleEntityDefinition {
     type: 'single';
-    /** Añadir updated_at */
-    timestamps?: boolean;
-    /** Añadir updated_by */
-    audit?: boolean;
+    /** Clave única en tabla sys_settings (ej: 'site_config', 'smtp_settings') */
+    key: string;
+    /** Nombre para mostrar en UI */
+    label: string;
+    /** Definición de campos (estructura del JSON value) */
+    fields: Record<string, FieldDefinition>;
+    /** Autorización CASL */
+    casl?: EntityCaslConfig;
 }
 /**
  * Entidad de referencia - Catálogos con CRUD admin (countries, currencies)
@@ -576,21 +645,6 @@ interface ModuleAbilities {
  * Usa BaseUser y AbilityLike para tipado básico sin depender del backend
  */
 type PluginAuthRequest = AuthRequest<BaseUser, AbilityLike>;
-/**
- * Resolver de usuarios para plugins
- * Permite acceder a usuarios sin conocer la implementación interna
- */
-interface UsersResolver {
-    findById: (id: string) => Promise<BaseUser | null>;
-    findByIds: (ids: string[]) => Promise<BaseUser[]>;
-}
-/**
- * Servicios core inyectados por el backend
- * Los plugins acceden a estos servicios via ctx.services
- */
-interface CoreServices {
-    users?: UsersResolver;
-}
 /**
  * Helpers para migraciones de base de datos
  */
@@ -655,8 +709,8 @@ interface ModuleContext {
             data?: Record<string, unknown>;
         }) => Promise<unknown>;
     };
-    /** Servicios de módulos core (users, etc.) */
-    services: CoreServices & Record<string, unknown>;
+    /** Servicios de módulos (inyectados por backend) */
+    services: Record<string, unknown>;
 }
 /**
  * Manifest de un módulo Nexus
@@ -664,8 +718,6 @@ interface ModuleContext {
 interface ModuleManifest {
     /** Identificador único del módulo (ej: 'users', 'posts') */
     name: string;
-    /** Código único del módulo (ej: 'USR', 'PST'). Opcional si pertenece a un plugin */
-    code?: string;
     /** Nombre para mostrar en UI. Opcional si pertenece a un plugin */
     label?: string;
     /** Icono del módulo (Iconify MDI: 'mdi:account-group') */
@@ -678,7 +730,7 @@ interface ModuleManifest {
     dependencies?: string[];
     /** Requisitos para activar el módulo */
     required?: ModuleRequirements;
-    /** Función de migración de base de datos */
+    /** Función de migración de base de datos. Normalmente se genera desde definitions (EntityDefinition) */
     migrate?: (ctx: ModuleContext) => Promise<void>;
     /** Función de seed de datos iniciales */
     seed?: (ctx: ModuleContext) => Promise<void>;
@@ -723,4 +775,4 @@ interface PluginManifest {
     modules: ModuleManifest[];
 }
 
-export { type AbilityLike, type ActionEntityDefinition, type AuthRequest, type BaseUser, type CaslAction, type CollectionEntityDefinition, type ComputedEntityDefinition, type ConfigEntityDefinition, type CoreServices, type DbType, type EntityCaslConfig, type EntityDefinition, type EntityIndex, type EventEntityDefinition, type ExternalEntityDefinition, type FieldCaslAccess, type FieldDbConfig, type FieldDefinition, type FieldMeta, type FieldOptions, type FieldRelation, type FieldValidation, type FieldValidationConfig, type ForbiddenErrorConstructor, type ForbiddenErrorInstance, type FormField, type FormFieldType, type GeneratedPermission, type InputType, type KnexAlterTableBuilder, type KnexCreateTableBuilder, type KnexTransaction, type ListType, type MigrationHelpers, type ModuleAbilities, type ModuleContext, type ModuleManifest, type ModuleMiddlewares, type ModuleRequirements, type OwnershipCondition, type PaginatedResult, type PaginationParams, type PluginAuthRequest, type PluginCategory, type PluginManifest, type ReferenceEntityDefinition, type RolePermission, type SingleEntityDefinition, type TempEntityDefinition, type UsersResolver, type ValidateSchemas, type ValidationSchema, type ViewEntityDefinition, type VirtualEntityDefinition, generateCaslPermissions, generateCaslSeed, generateMigration, generateModel, generateZodSchema, getEntitySubject };
+export { type AbilityLike, type ActionEntityDefinition, type AuthRequest, type BaseUser, type CaslAction, type CollectionEntityDefinition, type ComputedEntityDefinition, type ConfigEntityDefinition, type DbType, type EntityCaslConfig, type EntityDefinition, type EntityIndex, type EventEntityDefinition, type ExternalEntityDefinition, type FieldCaslAccess, type FieldDbConfig, type FieldDefinition, type FieldMeta, type FieldOptions, type FieldRelation, type FieldValidation, type FieldValidationConfig, type ForbiddenErrorConstructor, type ForbiddenErrorInstance, type FormField, type FormFieldType, GENERATED_DIR, type GeneratedPermission, type InputType, type KnexAlterTableBuilder, type KnexCreateTableBuilder, type KnexTransaction, type ListType, type MigrationHelpers, type ModuleAbilities, type ModuleContext, type ModuleManifest, type ModuleMiddlewares, type ModuleRequirements, type NonPersistentEntityDefinition, type OwnershipCondition, type PaginatedResult, type PaginationParams, type PersistentEntityDefinition, type PluginAuthRequest, type PluginCategory, type PluginManifest, type ReferenceEntityDefinition, type RolePermission, type SingleEntityDefinition, type TempEntityDefinition, type ValidateSchemas, type ValidationSchema, type ViewEntityDefinition, type VirtualEntityDefinition, generateCaslPermissions, generateCaslSeed, generateMigration, generateMigrationsFile, generateModel, generateModelsFile, generateReadOnlyModel, generateReadOnlySchema, generateSchemasFile, generateZodSchema, getEntityName, getEntitySubject, hasTable, isPersistentEntity, isSingletonEntity };

package/dist/index.js

@@ -1,7 +1,14 @@
 // src/generators.ts
+var GENERATED_DIR = "__generated__";
 function isPersistentEntity(entity) {
-  const nonPersistent = ["action", "external", "virtual", "computed"];
-  return !nonPersistent.includes(entity.type ?? "collection");
+  const withoutOwnTable = ["action", "external", "virtual", "computed", "single"];
+  return !withoutOwnTable.includes(entity.type ?? "collection");
+}
+function isSingletonEntity(entity) {
+  return entity.type === "single";
+}
+function hasTable(entity) {
+  return "table" in entity && typeof entity.table === "string";
 }
 function generateMigration(entity) {
   const { table, fields } = entity;
@@ -291,19 +298,81 @@ function dbTypeToTsType(db) {
       return "unknown";
   }
 }
+function toPascalCase(str) {
+  return str.split("_").map((p) => p.charAt(0).toUpperCase() + p.slice(1)).join("");
+}
+function toSingular(str) {
+  if (str.endsWith("ies")) return str.slice(0, -3) + "y";
+  if (str.endsWith("s")) return str.slice(0, -1);
+  return str;
+}
 function tableToEntityName(table) {
   const withoutPrefix = table.replace(/^[a-z]{2,4}_/, "");
-  const singular = withoutPrefix.endsWith("ies") ? withoutPrefix.slice(0, -3) + "y" : withoutPrefix.endsWith("s") ? withoutPrefix.slice(0, -1) : withoutPrefix;
-  return singular.charAt(0).toUpperCase() + singular.slice(1);
+  return toPascalCase(toSingular(withoutPrefix));
 }
 function tableToSubject(table) {
   const match = table.match(/^([a-z]{2,4})_(.+)$/);
   if (!match) return tableToEntityName(table);
   const [, prefix, rest] = match;
   const prefixPascal = prefix.charAt(0).toUpperCase() + prefix.slice(1);
-  const singular = rest.endsWith("ies") ? rest.slice(0, -3) + "y" : rest.endsWith("s") ? rest.slice(0, -1) : rest;
-  const restPascal = singular.charAt(0).toUpperCase() + singular.slice(1);
-  return prefixPascal + restPascal;
+  return prefixPascal + toPascalCase(toSingular(rest));
+}
+function labelToEntityName(label) {
+  const singular = label.endsWith("ies") ? label.slice(0, -3) + "y" : label.endsWith("s") ? label.slice(0, -1) : label;
+  return singular.charAt(0).toUpperCase() + singular.slice(1).replace(/\s+/g, "");
+}
+function generateReadOnlySchema(entity) {
+  const { label, fields } = entity;
+  const entityName = labelToEntityName(label);
+  const lines = [
+    `import { z } from 'zod'`,
+    ``,
+    `// === OUTPUT SCHEMA ===`,
+    `export const ${entityName.toLowerCase()}Schema = z.object({`
+  ];
+  for (const [name, field] of Object.entries(fields)) {
+    const zodType = dbTypeToZodType(field.db.type);
+    const nullable = field.db.nullable ? `.nullable()` : "";
+    lines.push(`  ${name}: ${zodType}${nullable},`);
+  }
+  lines.push(`})`);
+  lines.push(``);
+  lines.push(`// === QUERY ===`);
+  lines.push(`export const ${entityName.toLowerCase()}QuerySchema = z.object({`);
+  lines.push(`  page: z.coerce.number().int().min(1).default(1),`);
+  lines.push(`  limit: z.coerce.number().int().min(1).max(100).default(20),`);
+  for (const [name, field] of Object.entries(fields)) {
+    if (field.meta?.searchable) {
+      const zodType = dbTypeToZodType(field.db.type);
+      lines.push(`  ${name}: ${zodType}.optional(),`);
+    }
+  }
+  lines.push(`})`);
+  lines.push(``);
+  lines.push(`// === INFERRED TYPES ===`);
+  lines.push(`export type ${entityName} = z.infer<typeof ${entityName.toLowerCase()}Schema>`);
+  lines.push(`export type ${entityName}Query = z.infer<typeof ${entityName.toLowerCase()}QuerySchema>`);
+  lines.push(``);
+  return lines.join("\n");
+}
+function generateReadOnlyModel(entity) {
+  const { label, fields } = entity;
+  const entityName = labelToEntityName(label);
+  const lines = [
+    `/**`,
+    ` * ${label}`,
+    ` * Generated from EntityDefinition (${entity.type})`,
+    ` */`,
+    `export interface ${entityName} {`
+  ];
+  for (const [name, field] of Object.entries(fields)) {
+    const tsType = dbTypeToTsType(field.db);
+    const optional = field.db.nullable ? "?" : "";
+    lines.push(`  ${name}${optional}: ${tsType}`);
+  }
+  lines.push(`}`);
+  lines.push(``);
+  return lines.join("\n");
 }
 function getFieldsForRole(entity, role, action) {
   const { fields, casl } = entity;
@@ -441,11 +510,296 @@ function generateCaslSeed(entities) {
 function getEntitySubject(entity) {
   return entity.casl?.subject ?? tableToSubject(entity.table);
 }
+function getEntityName(entity) {
+  if ("table" in entity) {
+    const withoutPrefix = entity.table.replace(/^[a-z]{2,4}_/, "");
+    return toPascalCase(toSingular(withoutPrefix));
+  } else if ("key" in entity) {
+    return toPascalCase(entity.key);
+  } else {
+    return toSingular(entity.label).replace(/\s+/g, "");
+  }
+}
+function dbTypeToZodSimple(type, nullable) {
+  let zod = "";
+  switch (type) {
+    case "string":
+    case "text":
+    case "uuid":
+      zod = "z.string()";
+      break;
+    case "integer":
+      zod = "z.number().int()";
+      break;
+    case "decimal":
+      zod = "z.number()";
+      break;
+    case "boolean":
+      zod = "z.boolean()";
+      break;
+    case "date":
+    case "datetime":
+      zod = "z.string().datetime()";
+      break;
+    case "json":
+      zod = "z.record(z.unknown())";
+      break;
+    default:
+      zod = "z.unknown()";
+  }
+  return nullable ? `${zod}.nullable()` : zod;
+}
+function dbTypeToTsSimple(type) {
+  switch (type) {
+    case "string":
+    case "text":
+    case "uuid":
+      return "string";
+    case "integer":
+    case "decimal":
+      return "number";
+    case "boolean":
+      return "boolean";
+    case "date":
+    case "datetime":
+      return "Date";
+    case "json":
+      return "Record<string, unknown>";
+    default:
+      return "unknown";
+  }
+}
+function generateSchemasFile(definitions) {
+  const lines = [
+    "/**",
+    " * AUTO-GENERATED - Do not edit manually",
+    " * Generated from EntityDefinition via @gzl10/nexus-sdk generators",
+    " */",
+    "",
+    "import { z } from 'zod'",
+    ""
+  ];
+  for (const entity of definitions) {
+    const name = getEntityName(entity);
+    lines.push(`// ============================================================================`);
+    lines.push(`// ${name.toUpperCase()} (${entity.type ?? "collection"})`);
+    lines.push(`// ============================================================================`);
+    lines.push("");
+    if (isPersistentEntity(entity)) {
+      const schema = generateZodSchema(entity);
+      const schemaLines = schema.split("\n").filter(
+        (l) => !l.startsWith("import") && l.trim() !== ""
+      );
+      lines.push(...schemaLines);
+    } else if (entity.type === "single") {
+      lines.push(`export const ${name.toLowerCase()}Schema = z.object({`);
+      for (const [fieldName, field] of Object.entries(entity.fields)) {
+        const zodType = dbTypeToZodSimple(field.db.type, field.db.nullable);
+        lines.push(`  ${fieldName}: ${zodType},`);
+      }
+      lines.push("})");
+      lines.push("");
+      lines.push(`export type ${name} = z.infer<typeof ${name.toLowerCase()}Schema>`);
+    } else {
+      const schema = generateReadOnlySchema(entity);
+      const schemaLines = schema.split("\n").filter(
+        (l) => !l.startsWith("import") && l.trim() !== ""
+      );
+      lines.push(...schemaLines);
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function generateModelsFile(definitions) {
+  const lines = [
+    "/**",
+    " * AUTO-GENERATED - Do not edit manually",
+    " * Generated from EntityDefinition via @gzl10/nexus-sdk generators",
+    " */",
+    ""
+  ];
+  for (const entity of definitions) {
+    const name = getEntityName(entity);
+    lines.push(`// ============================================================================`);
+    lines.push(`// ${name.toUpperCase()} (${entity.type ?? "collection"})`);
+    lines.push(`// ============================================================================`);
+    lines.push("");
+    if (isPersistentEntity(entity)) {
+      const model = generateModel(entity);
+      const modelLines = model.split("\n");
+      lines.push(...modelLines);
+    } else if (entity.type === "single") {
+      lines.push(`/**`);
+      lines.push(` * ${entity.label}`);
+      lines.push(` * Generated from EntityDefinition (single)`);
+      lines.push(` */`);
+      lines.push(`export interface ${name} {`);
+      for (const [fieldName, field] of Object.entries(entity.fields)) {
+        const tsType = dbTypeToTsSimple(field.db.type);
+        const optional = field.db.nullable ? "?" : "";
+        lines.push(`  ${fieldName}${optional}: ${tsType}`);
+      }
+      lines.push("}");
+    } else {
+      const model = generateReadOnlyModel(entity);
+      lines.push(model);
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function generateMigrationsFile(definitions) {
+  const persistentEntities = definitions.filter(isPersistentEntity);
+  if (persistentEntities.length === 0) {
+    return [
+      "/**",
+      " * AUTO-GENERATED - Do not edit manually",
+      " * Generated from EntityDefinition via @gzl10/nexus-sdk generators",
+      " */",
+      "",
+      "import type { ModuleContext } from '@gzl10/nexus-sdk'",
+      "",
+      "// No persistent entities to migrate",
+      "export async function migrate(_ctx: ModuleContext): Promise<void> {}",
+      ""
+    ].join("\n");
+  }
+  const lines = [
+    "/**",
+    " * AUTO-GENERATED - Do not edit manually",
+    " * Generated from EntityDefinition via @gzl10/nexus-sdk generators",
+    " */",
+    "",
+    "import type { ModuleContext, Knex } from '@gzl10/nexus-sdk'",
+    "",
+    "export async function migrate(ctx: ModuleContext): Promise<void> {",
+    "  const { db, logger, helpers } = ctx",
+    "  const { addTimestamps, addAuditFieldsIfMissing } = helpers",
+    ""
+  ];
+  for (const entity of persistentEntities) {
+    const { table, fields } = entity;
+    const timestamps = "timestamps" in entity ? entity.timestamps : false;
+    const audit = "audit" in entity ? entity.audit : false;
+    const indexes = "indexes" in entity ? entity.indexes : void 0;
+    const name = getEntityName(entity);
+    lines.push(`  // === ${name.toUpperCase()} ===`);
+    lines.push(`  if (!(await db.schema.hasTable('${table}'))) {`);
+    lines.push(`    await db.schema.createTable('${table}', (table: Knex.CreateTableBuilder) => {`);
+    for (const [fieldName, field] of Object.entries(fields)) {
+      const columnCode = generateColumnCodeInline(fieldName, field);
+      lines.push(`      ${columnCode}`);
+    }
+    if (timestamps) {
+      lines.push(`      addTimestamps(table, db)`);
+    }
+    if (indexes?.length) {
+      lines.push("");
+      for (const idx of indexes) {
+        if (idx.unique) {
+          lines.push(`      table.unique([${idx.columns.map((c) => `'${c}'`).join(", ")}])`);
+        } else {
+          lines.push(`      table.index([${idx.columns.map((c) => `'${c}'`).join(", ")}])`);
+        }
+      }
+    }
+    lines.push(`    })`);
+    lines.push(`    logger.info('Created table: ${table}')`);
+    lines.push(`  }`);
+    if (audit) {
+      lines.push(`  await addAuditFieldsIfMissing(db, '${table}')`);
+    }
+    lines.push("");
+  }
+  lines.push("}");
+  lines.push("");
+  return lines.join("\n");
+}
+function generateColumnCodeInline(name, field) {
+  const { db } = field;
+  let code = "";
+  switch (db.type) {
+    case "string":
+      code = db.size ? `table.string('${name}', ${db.size})` : `table.string('${name}')`;
+      break;
+    case "text":
+      code = `table.text('${name}')`;
+      break;
+    case "integer":
+      code = `table.integer('${name}')`;
+      break;
+    case "decimal":
+      if (db.precision) {
+        code = `table.decimal('${name}', ${db.precision[0]}, ${db.precision[1]})`;
+      } else {
+        code = `table.decimal('${name}')`;
+      }
+      break;
+    case "boolean":
+      code = `table.boolean('${name}')`;
+      break;
+    case "date":
+      code = `table.date('${name}')`;
+      break;
+    case "datetime":
+      code = `table.datetime('${name}')`;
+      break;
+    case "json":
+      code = `table.json('${name}')`;
+      break;
+    case "uuid":
+      code = `table.uuid('${name}')`;
+      break;
+    default:
+      code = `table.string('${name}')`;
+  }
+  if (name === "id") {
+    code += ".primary()";
+  }
+  if (!db.nullable) {
+    code += ".notNullable()";
+  } else {
+    code += ".nullable()";
+  }
+  if (db.unique) {
+    code += ".unique()";
+  }
+  if (db.default !== void 0) {
+    if (typeof db.default === "string") {
+      code += `.defaultTo('${db.default}')`;
+    } else if (typeof db.default === "boolean") {
+      code += `.defaultTo(${db.default})`;
+    } else {
+      code += `.defaultTo(${db.default})`;
+    }
+  }
+  if (db.index) {
+    code += ".index()";
+  }
+  if (field.relation) {
+    code += `.references('${field.relation.column ?? "id"}').inTable('${field.relation.table}')`;
+    if (field.relation.onDelete) {
+      code += `.onDelete('${field.relation.onDelete}')`;
+    }
+  }
+  return code;
+}
 export {
+  GENERATED_DIR,
   generateCaslPermissions,
   generateCaslSeed,
   generateMigration,
+  generateMigrationsFile,
   generateModel,
+  generateModelsFile,
+  generateReadOnlyModel,
+  generateReadOnlySchema,
+  generateSchemasFile,
   generateZodSchema,
-  getEntitySubject
+  getEntityName,
+  getEntitySubject,
+  hasTable,
+  isPersistentEntity,
+  isSingletonEntity
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gzl10/nexus-sdk",
-  "version": "0.3.0",
+  "version": "0.4.1",
   "description": "SDK types for creating Nexus plugins and modules",
   "type": "module",
   "main": "./dist/index.js",