drizzle-multitenant 1.1.0 → 1.3.0

package/dist/lint/index.d.ts

@@ -0,0 +1,475 @@
+/**
+ * Schema Linting Module Types
+ *
+ * Provides type definitions for schema validation and linting.
+ */
+/**
+ * Severity level for lint rules
+ */
+type LintSeverity = 'off' | 'warn' | 'error';
+/**
+ * Naming style options
+ */
+type NamingStyle = 'snake_case' | 'camelCase' | 'PascalCase' | 'kebab-case';
+/**
+ * Rule configuration - can be severity only or [severity, options]
+ */
+type RuleConfig<TOptions = Record<string, unknown>> = LintSeverity | [LintSeverity, TOptions];
+/**
+ * Naming rule options
+ */
+interface NamingRuleOptions {
+    style: NamingStyle;
+    /** Allow exceptions matching these patterns */
+    exceptions?: string[];
+}
+/**
+ * Lint configuration for defineConfig
+ */
+interface LintConfig {
+    rules: LintRules;
+    /** Glob patterns to include */
+    include?: string[];
+    /** Glob patterns to exclude */
+    exclude?: string[];
+    /** Custom rules directory */
+    customRulesDir?: string;
+}
+/**
+ * All available lint rules
+ */
+interface LintRules {
+    'table-naming'?: RuleConfig<NamingRuleOptions>;
+    'column-naming'?: RuleConfig<NamingRuleOptions>;
+    'require-primary-key'?: RuleConfig;
+    'prefer-uuid-pk'?: RuleConfig;
+    'require-timestamps'?: RuleConfig<{
+        columns?: string[];
+    }>;
+    'index-foreign-keys'?: RuleConfig;
+    'no-cascade-delete'?: RuleConfig;
+    'require-soft-delete'?: RuleConfig<{
+        column?: string;
+    }>;
+}
+/**
+ * Default lint rules configuration
+ */
+declare const DEFAULT_LINT_RULES: LintRules;
+/**
+ * Represents a column in a schema
+ */
+interface SchemaColumn {
+    name: string;
+    dataType: string;
+    isPrimaryKey: boolean;
+    isNullable: boolean;
+    hasDefault: boolean;
+    defaultValue?: string | null | undefined;
+    references?: {
+        table: string;
+        column: string;
+        onDelete?: string | undefined;
+        onUpdate?: string | undefined;
+    } | undefined;
+}
+/**
+ * Represents an index in a schema
+ */
+interface SchemaIndex {
+    name: string;
+    columns: string[];
+    isUnique: boolean;
+}
+/**
+ * Represents a table in a schema
+ */
+interface SchemaTable {
+    name: string;
+    schemaType: 'tenant' | 'shared';
+    columns: SchemaColumn[];
+    indexes: SchemaIndex[];
+    filePath: string;
+}
+/**
+ * Parsed schema info for linting
+ */
+interface ParsedSchema {
+    tables: SchemaTable[];
+    filePath: string;
+}
+/**
+ * A single lint issue
+ */
+interface LintIssue {
+    /** Rule that triggered this issue */
+    rule: string;
+    /** Severity level */
+    severity: 'warn' | 'error';
+    /** Human-readable message */
+    message: string;
+    /** File path where issue was found */
+    filePath: string;
+    /** Table name (if applicable) */
+    table?: string;
+    /** Column name (if applicable) */
+    column?: string;
+    /** Line number (if available) */
+    line?: number;
+    /** Suggestion to fix the issue */
+    suggestion?: string;
+}
+/**
+ * Result of linting a single schema file
+ */
+interface LintFileResult {
+    filePath: string;
+    issues: LintIssue[];
+    tables: number;
+    columns: number;
+}
+/**
+ * Aggregate result of linting all schemas
+ */
+interface LintResult {
+    /** All file results */
+    files: LintFileResult[];
+    /** Total issues by severity */
+    summary: {
+        totalFiles: number;
+        totalTables: number;
+        totalColumns: number;
+        errors: number;
+        warnings: number;
+    };
+    /** Duration in milliseconds */
+    durationMs: number;
+    /** Whether linting passed (no errors) */
+    passed: boolean;
+}
+/**
+ * Output format for reporters
+ */
+type ReporterFormat = 'console' | 'json' | 'github';
+/**
+ * Reporter options
+ */
+interface ReporterOptions {
+    format: ReporterFormat;
+    /** Show only issues (no summary) */
+    quiet?: boolean;
+    /** Show detailed output */
+    verbose?: boolean;
+    /** Use colors in output */
+    colors?: boolean;
+}
+/**
+ * Rule context passed to rule implementations
+ */
+interface RuleContext {
+    /** Report an issue */
+    report: (issue: Omit<LintIssue, 'rule' | 'severity'>) => void;
+    /** Current severity for this rule */
+    severity: 'warn' | 'error';
+    /** Rule options (if any) */
+    options: Record<string, unknown>;
+}
+/**
+ * Rule implementation interface
+ */
+interface LintRule {
+    /** Rule name */
+    name: string;
+    /** Rule description */
+    description: string;
+    /** Default severity */
+    defaultSeverity: LintSeverity;
+    /** Validate a table */
+    validateTable?: (table: SchemaTable, context: RuleContext) => void;
+    /** Validate a column */
+    validateColumn?: (column: SchemaColumn, table: SchemaTable, context: RuleContext) => void;
+    /** Validate the entire schema */
+    validateSchema?: (tables: SchemaTable[], context: RuleContext) => void;
+}
+/**
+ * Schema file detection result
+ */
+interface SchemaFileInfo {
+    filePath: string;
+    type: 'tenant' | 'shared';
+}
+/**
+ * Linter options
+ */
+interface LinterOptions {
+    /** Schema directories to lint */
+    schemaDirs?: {
+        tenant?: string;
+        shared?: string;
+    };
+    /** Glob patterns for schema files */
+    include?: string[];
+    /** Glob patterns to exclude */
+    exclude?: string[];
+    /** Rules configuration */
+    rules?: LintRules;
+}
+
+/**
+ * Schema Parser
+ *
+ * Parses Drizzle ORM schema files to extract table, column, and index information
+ * for linting purposes.
+ */
+
+/**
+ * Parse a Drizzle schema module to extract table information
+ */
+declare function parseSchemaModule(module: Record<string, unknown>, filePath: string, schemaType: 'tenant' | 'shared'): SchemaTable[];
+/**
+ * Parse a raw table definition (for testing or direct input)
+ */
+declare function parseRawTable(name: string, columns: Array<{
+    name: string;
+    dataType: string;
+    isPrimaryKey?: boolean;
+    isNullable?: boolean;
+    hasDefault?: boolean;
+    defaultValue?: string | null;
+    references?: SchemaColumn['references'];
+}>, options?: {
+    schemaType?: 'tenant' | 'shared';
+    filePath?: string;
+    indexes?: Array<{
+        name: string;
+        columns: string[];
+        isUnique?: boolean;
+    }>;
+}): SchemaTable;
+/**
+ * Find schema files in a directory
+ */
+declare function findSchemaFiles(dir: string, type: 'tenant' | 'shared'): Promise<SchemaFileInfo[]>;
+/**
+ * Load and parse a schema file
+ */
+declare function loadSchemaFile(filePath: string, type: 'tenant' | 'shared'): Promise<SchemaTable[]>;
+
+/**
+ * Schema Linter
+ *
+ * Main linter class that orchestrates schema validation using configured rules.
+ */
+
+/**
+ * Schema Linter
+ *
+ * Validates Drizzle ORM schemas against configurable rules.
+ *
+ * @example
+ * ```typescript
+ * const linter = new SchemaLinter({
+ *   rules: {
+ *     'table-naming': ['error', { style: 'snake_case' }],
+ *     'require-primary-key': 'error',
+ *     'prefer-uuid-pk': 'warn',
+ *   },
+ * });
+ *
+ * const result = await linter.lintDirectory('./src/db/schema');
+ * console.log(result.passed ? 'All good!' : 'Issues found');
+ * ```
+ */
+declare class SchemaLinter {
+    private rules;
+    private config;
+    constructor(options?: Partial<LinterOptions>);
+    /**
+     * Get the effective severity for a rule
+     */
+    getEffectiveSeverity(ruleName: string): LintSeverity;
+    /**
+     * Get the options for a rule
+     */
+    getRuleOptions(ruleName: string): Record<string, unknown>;
+    /**
+     * Check if a rule is enabled
+     */
+    isRuleEnabled(ruleName: string): boolean;
+    /**
+     * Lint a single table
+     */
+    lintTable(table: SchemaTable): LintIssue[];
+    /**
+     * Lint multiple tables
+     */
+    lintTables(tables: SchemaTable[]): LintResult;
+    /**
+     * Lint a schema module (object with table exports)
+     */
+    lintModule(module: Record<string, unknown>, filePath: string, schemaType?: 'tenant' | 'shared'): LintResult;
+    /**
+     * Lint schema files in a directory
+     */
+    lintDirectory(dir: string, type?: 'tenant' | 'shared'): Promise<LintResult>;
+    /**
+     * Lint multiple directories (tenant and shared)
+     */
+    lintDirectories(options: {
+        tenant?: string;
+        shared?: string;
+    }): Promise<LintResult>;
+    /**
+     * Get all registered rules
+     */
+    getRules(): LintRule[];
+    /**
+     * Get a specific rule by name
+     */
+    getRule(name: string): LintRule | undefined;
+    /**
+     * Register a custom rule
+     */
+    registerRule(rule: LintRule): void;
+    /**
+     * Update rule configuration
+     */
+    setRuleConfig(ruleName: string, config: RuleConfig): void;
+    /**
+     * Get current configuration
+     */
+    getConfig(): LintRules;
+}
+/**
+ * Create a linter instance with configuration
+ */
+declare function createLinter(options?: Partial<LinterOptions>): SchemaLinter;
+/**
+ * Quick lint function for simple use cases
+ */
+declare function lintSchemas(options: {
+    tenant?: string;
+    shared?: string;
+    rules?: LintRules;
+}): Promise<LintResult>;
+
+/**
+ * Lint Reporter
+ *
+ * Formats and outputs lint results in various formats.
+ */
+
+/**
+ * Format lint results according to the specified format
+ */
+declare function formatLintResult(result: LintResult, options: ReporterOptions): string;
+/**
+ * Create a reporter function for the specified format
+ */
+declare function createReporter(format: ReporterFormat, options?: Partial<ReporterOptions>): (result: LintResult) => string;
+/**
+ * Print lint result to stdout
+ */
+declare function printLintResult(result: LintResult, options: ReporterOptions): void;
+
+/**
+ * Naming Convention Rules
+ *
+ * Rules for validating table and column naming conventions.
+ */
+
+/**
+ * Table naming rule
+ *
+ * Validates that table names follow the configured naming convention.
+ */
+declare const tableNamingRule: LintRule;
+/**
+ * Column naming rule
+ *
+ * Validates that column names follow the configured naming convention.
+ */
+declare const columnNamingRule: LintRule;
+/**
+ * All naming rules
+ */
+declare const namingRules: LintRule[];
+
+/**
+ * Convention Rules
+ *
+ * Rules for validating schema best practices and conventions.
+ */
+
+/**
+ * Require primary key rule
+ *
+ * Every table should have a primary key defined.
+ */
+declare const requirePrimaryKeyRule: LintRule;
+/**
+ * Prefer UUID primary key rule
+ *
+ * Recommends using UUID over serial/integer for primary keys.
+ */
+declare const preferUuidPkRule: LintRule;
+/**
+ * Require timestamps rule
+ *
+ * Tables should have created_at and updated_at columns.
+ */
+declare const requireTimestampsRule: LintRule;
+/**
+ * Index foreign keys rule
+ *
+ * Foreign key columns should have indexes for query performance.
+ */
+declare const indexForeignKeysRule: LintRule;
+/**
+ * All convention rules
+ */
+declare const conventionRules: LintRule[];
+
+/**
+ * Security Rules
+ *
+ * Rules for validating schema security best practices.
+ */
+
+/**
+ * No cascade delete rule
+ *
+ * Warns about CASCADE DELETE which can accidentally remove data.
+ */
+declare const noCascadeDeleteRule: LintRule;
+/**
+ * Require soft delete rule
+ *
+ * Tables should have a soft delete column instead of hard deletes.
+ */
+declare const requireSoftDeleteRule: LintRule;
+/**
+ * All security rules
+ */
+declare const securityRules: LintRule[];
+
+/**
+ * Lint Rules Export
+ *
+ * Aggregates all available lint rules.
+ */
+
+/**
+ * All built-in rules
+ */
+declare const allRules: LintRule[];
+/**
+ * Get rule by name
+ */
+declare function getRuleByName(name: string): LintRule | undefined;
+/**
+ * Get all rule names
+ */
+declare function getAllRuleNames(): string[];
+
+export { DEFAULT_LINT_RULES, type LintConfig, type LintFileResult, type LintIssue, type LintResult, type LintRule, type LintRules, type LintSeverity, type LinterOptions, type NamingRuleOptions, type NamingStyle, type ParsedSchema, type ReporterFormat, type ReporterOptions, type RuleConfig, type RuleContext, type SchemaColumn, type SchemaFileInfo, type SchemaIndex, SchemaLinter, type SchemaTable, allRules, columnNamingRule, conventionRules, createLinter, createReporter, findSchemaFiles, formatLintResult, getAllRuleNames, getRuleByName, indexForeignKeysRule, lintSchemas, loadSchemaFile, namingRules, noCascadeDeleteRule, parseRawTable, parseSchemaModule, preferUuidPkRule, printLintResult, requirePrimaryKeyRule, requireSoftDeleteRule, requireTimestampsRule, securityRules, tableNamingRule };

package/dist/lint/index.js

@@ -0,0 +1,5 @@
+var L={"table-naming":["warn",{style:"snake_case"}],"column-naming":["warn",{style:"snake_case"}],"require-primary-key":"error","prefer-uuid-pk":"warn","require-timestamps":"off","index-foreign-keys":"warn","no-cascade-delete":"off","require-soft-delete":"off"};function A(e){return /^[a-z][a-z0-9]*(_[a-z0-9]+)*$/.test(e)}function j(e){return /^[a-z][a-zA-Z0-9]*$/.test(e)&&!e.includes("_")}function z(e){return /^[A-Z][a-zA-Z0-9]*$/.test(e)&&!e.includes("_")}function K(e){return /^[a-z][a-z0-9]*(-[a-z0-9]+)*$/.test(e)}function I(e,t){switch(t){case "snake_case":return A(e);case "camelCase":return j(e);case "PascalCase":return z(e);case "kebab-case":return K(e);default:return  true}}function O(e,t){let n=e.replace(/([a-z])([A-Z])/g,"$1_$2").replace(/-/g,"_").toLowerCase().split("_").filter(Boolean);switch(t){case "snake_case":return n.join("_");case "camelCase":return n.map((s,i)=>i===0?s:s.charAt(0).toUpperCase()+s.slice(1)).join("");case "PascalCase":return n.map(s=>s.charAt(0).toUpperCase()+s.slice(1)).join("");case "kebab-case":return n.join("-");default:return e}}function q(e,t){return t?.length?t.some(n=>new RegExp("^"+n.replace(/\*/g,".*")+"$").test(e)):false}var w={name:"table-naming",description:"Enforce consistent table naming convention",defaultSeverity:"warn",validateTable(e,t){let n=t.options,s=n.style??"snake_case",i=n.exceptions??[];if(!q(e.name,i)&&!I(e.name,s)){let r=O(e.name,s);t.report({message:`Table "${e.name}" does not follow ${s} convention`,filePath:e.filePath,table:e.name,suggestion:`Consider renaming to "${r}"`});}}},v={name:"column-naming",description:"Enforce consistent column naming convention",defaultSeverity:"warn",validateColumn(e,t,n){let s=n.options,i=s.style??"snake_case",r=s.exceptions??[];if(!q(e.name,r)&&!I(e.name,i)){let a=O(e.name,i);n.report({message:`Column "${e.name}" in table "${t.name}" does not follow ${i} convention`,filePath:t.filePath,table:t.name,column:e.name,suggestion:`Consider renaming to "${a}"`});}}},R=[w,v];var T={name:"require-primary-key",description:"Require every table to have a primary key",defaultSeverity:"error",validateTable(e,t){e.columns.some(s=>s.isPrimaryKey)||t.report({message:`Table "${e.name}" does not have a primary key`,filePath:e.filePath,table:e.name,suggestion:"Add a primary key column (e.g., id: uuid().primaryKey())"});}},P={name:"prefer-uuid-pk",description:"Prefer UUID over serial/integer for primary keys",defaultSeverity:"warn",validateColumn(e,t,n){if(!e.isPrimaryKey)return;let s=["serial","bigserial","smallserial","integer","bigint","smallint"],i=e.dataType.toLowerCase();s.some(r=>i.includes(r))&&n.report({message:`Table "${t.name}" uses ${e.dataType} for primary key instead of UUID`,filePath:t.filePath,table:t.name,column:e.name,suggestion:"Consider using uuid() for better distribution and security"});}},k={name:"require-timestamps",description:"Require timestamp columns (created_at, updated_at) on tables",defaultSeverity:"warn",validateTable(e,t){let s=t.options.columns??["created_at","updated_at"],i=e.columns.map(r=>r.name.toLowerCase());for(let r of s){let a=r.toLowerCase(),o=r.replace(/_([a-z])/g,(l,u)=>u.toUpperCase()).toLowerCase();!i.includes(a)&&!i.includes(o)&&t.report({message:`Table "${e.name}" is missing "${r}" column`,filePath:e.filePath,table:e.name,suggestion:`Add ${a}: timestamp('${a}').defaultNow().notNull()`});}}},$={name:"index-foreign-keys",description:"Require indexes on foreign key columns",defaultSeverity:"warn",validateTable(e,t){let n=e.columns.filter(r=>r.references),s=new Set;for(let r of e.indexes){let a=r.columns[0];a&&s.add(a.toLowerCase());}let i=e.columns.filter(r=>r.isPrimaryKey);for(let r of i)s.add(r.name.toLowerCase());for(let r of n)s.has(r.name.toLowerCase())||t.report({message:`Foreign key column "${r.name}" in table "${e.name}" is not indexed`,filePath:e.filePath,table:e.name,column:r.name,suggestion:`Add index: index('${e.name}_${r.name}_idx').on(${e.name}.${r.name})`});}},b=[T,P,k,$];var N={name:"no-cascade-delete",description:"Warn about CASCADE DELETE on foreign keys",defaultSeverity:"warn",validateColumn(e,t,n){if(!e.references)return;e.references.onDelete?.toLowerCase()==="cascade"&&n.report({message:`Foreign key "${e.name}" in table "${t.name}" uses CASCADE DELETE`,filePath:t.filePath,table:t.name,column:e.name,suggestion:"Consider using SET NULL, RESTRICT, or implementing soft delete to prevent accidental data loss"});}},D={name:"require-soft-delete",description:"Require soft delete column on tables",defaultSeverity:"off",validateTable(e,t){let s=t.options.column??"deleted_at",i=s.toLowerCase(),r=s.replace(/_([a-z])/g,(o,l)=>l.toUpperCase()).toLowerCase(),a=e.columns.map(o=>o.name.toLowerCase());!a.includes(i)&&!a.includes(r)&&t.report({message:`Table "${e.name}" does not have a soft delete column ("${s}")`,filePath:e.filePath,table:e.name,suggestion:`Add ${i}: timestamp('${i}') for soft delete support`});}},x=[N,D];var g=[...R,...b,...x];function M(e){return g.find(t=>t.name===e)}function Z(){return g.map(e=>e.name)}var V=Symbol.for("drizzle:Table"),B=Symbol.for("drizzle:Column");function W(e){if(!e||typeof e!="object")return  false;let t=e;if(t._&&typeof t._=="object"){let n=t._;return typeof n.name=="string"&&(n.schema===void 0||typeof n.schema=="string")}return !!Object.getOwnPropertySymbols(t).some(n=>n===V)}function J(e){if(!e||typeof e!="object")return  false;let t=e;return typeof t.name=="string"||typeof t.columnType=="string"||typeof t.dataType=="string"||Object.getOwnPropertySymbols(t).some(n=>n===B)}function Q(e,t){let n=t.name??e,s="unknown";if(typeof t.dataType=="string")s=t.dataType;else if(typeof t.columnType=="string")s=t.columnType;else if(typeof t.getSQLType=="function")try{s=t.getSQLType();}catch{}let i=t.primary===true||t.isPrimaryKey===true||typeof t.primaryKey=="function"&&t._isPrimaryKey===true,r=t.notNull!==true&&t.isNotNull!==true,a=t.hasDefault===true||t.default!==void 0,o=t.default!==void 0?String(t.default):null,l;if(t.references&&typeof t.references=="object"){let u=t.references;l={table:u.table??"unknown",column:u.column??"unknown",onDelete:u.onDelete,onUpdate:u.onUpdate};}return {name:n,dataType:s,isPrimaryKey:i,isNullable:r,hasDefault:a,defaultValue:o,references:l}}function Y(e){let t=[],n=e._indexes??e.indexes;if(n&&typeof n=="object")for(let[s,i]of Object.entries(n)){if(!i||typeof i!="object")continue;let r=i,a=[];if(Array.isArray(r.columns))for(let o of r.columns)typeof o=="string"?a.push(o):o&&typeof o=="object"&&"name"in o&&a.push(String(o.name));t.push({name:s,columns:a,isUnique:r.isUnique===true||r.unique===true});}return t}function S(e,t,n){let s=[];for(let[i,r]of Object.entries(e)){if(!W(r))continue;let a=r,l=a._?.name??i,u=[];for(let[m,d]of Object.entries(a)){if(m==="_"||m.startsWith("_")||!J(d))continue;let f=Q(m,d);u.push(f);}let p=Y(a);s.push({name:l,schemaType:n,columns:u,indexes:p,filePath:t});}return s}function F(e,t,n){return {name:e,schemaType:n?.schemaType??"tenant",filePath:n?.filePath??"unknown",columns:t.map(s=>({name:s.name,dataType:s.dataType,isPrimaryKey:s.isPrimaryKey??false,isNullable:s.isNullable??true,hasDefault:s.hasDefault??false,defaultValue:s.defaultValue??null,references:s.references})),indexes:n?.indexes?.map(s=>({name:s.name,columns:s.columns,isUnique:s.isUnique??false}))??[]}}async function y(e,t){let{glob:n}=await import('glob'),{resolve:s}=await import('path'),i=s(e,"**/*.ts");return (await n(i,{ignore:["**/*.test.ts","**/*.spec.ts","**/node_modules/**"]})).map(a=>({filePath:a,type:t}))}async function h(e,t){try{let n=await import(e);return S(n,e,t)}catch(n){return console.warn(`Warning: Could not parse schema file ${e}:`,n.message),[]}}function G(e){return e?typeof e=="string"?e:e[0]:"off"}function H(e){return e?typeof e=="string"?{}:e[1]??{}:{}}var C=class{rules=new Map;config;constructor(t){this.config={...L,...t?.rules};for(let n of g)this.rules.set(n.name,n);}getEffectiveSeverity(t){let n=this.config[t];return G(n)}getRuleOptions(t){let n=this.config[t];return H(n)}isRuleEnabled(t){return this.getEffectiveSeverity(t)!=="off"}lintTable(t){let n=[];for(let[s,i]of this.rules){let r=this.getEffectiveSeverity(s);if(r==="off")continue;let a=this.getRuleOptions(s),o={severity:r,options:a,report:l=>{n.push({rule:s,severity:r,...l});}};if(i.validateTable&&i.validateTable(t,o),i.validateColumn)for(let l of t.columns)i.validateColumn(l,t,o);}return n}lintTables(t){let n=Date.now(),s=new Map;for(let o of t){s.has(o.filePath)||s.set(o.filePath,{filePath:o.filePath,issues:[],tables:0,columns:0});let l=s.get(o.filePath);l.tables++,l.columns+=o.columns.length;let u=this.lintTable(o);l.issues.push(...u);}for(let[o,l]of this.rules){if(!l.validateSchema)continue;let u=this.getEffectiveSeverity(o);if(u==="off")continue;let p=this.getRuleOptions(o),m={severity:u,options:p,report:d=>{let f=d.filePath||"schema";s.has(f)||s.set(f,{filePath:f,issues:[],tables:0,columns:0}),s.get(f).issues.push({rule:o,severity:u,...d});}};l.validateSchema(t,m);}let i=Array.from(s.values()),r=i.flatMap(o=>o.issues),a={totalFiles:i.length,totalTables:i.reduce((o,l)=>o+l.tables,0),totalColumns:i.reduce((o,l)=>o+l.columns,0),errors:r.filter(o=>o.severity==="error").length,warnings:r.filter(o=>o.severity==="warn").length};return {files:i,summary:a,durationMs:Date.now()-n,passed:a.errors===0}}lintModule(t,n,s="tenant"){let i=S(t,n,s);return this.lintTables(i)}async lintDirectory(t,n="tenant"){let s=Date.now(),i=await y(t,n),r=[];for(let o of i){let l=await h(o.filePath,o.type);r.push(...l);}let a=this.lintTables(r);return a.durationMs=Date.now()-s,a}async lintDirectories(t){let n=Date.now(),s=[];if(t.tenant){let r=await y(t.tenant,"tenant");for(let a of r){let o=await h(a.filePath,a.type);s.push(...o);}}if(t.shared){let r=await y(t.shared,"shared");for(let a of r){let o=await h(a.filePath,a.type);s.push(...o);}}let i=this.lintTables(s);return i.durationMs=Date.now()-n,i}getRules(){return Array.from(this.rules.values())}getRule(t){return this.rules.get(t)}registerRule(t){this.rules.set(t.name,t);}setRuleConfig(t,n){this.config[t]=n;}getConfig(){return {...this.config}}};function E(e){return new C(e)}async function X(e){let t=E(e.rules?{rules:e.rules}:void 0),n={};return e.tenant&&(n.tenant=e.tenant),e.shared&&(n.shared=e.shared),t.lintDirectories(n)}var U={reset:"\x1B[0m",red:"\x1B[31m",yellow:"\x1B[33m",green:"\x1B[32m",cyan:"\x1B[36m",dim:"\x1B[2m",bold:"\x1B[1m"};function c(e,t,n){return n?`${U[t]}${e}${U.reset}`:e}function ee(e,t){let n=e.severity==="error"?c("error","red",t):c("warn","yellow",t),s=e.column?`${e.table}.${e.column}`:e.table??e.filePath,i=c(`(${e.rule})`,"dim",t),r=`  ${n}  ${e.message} ${i}`;return r+=`
+         ${c(s,"dim",t)}`,e.suggestion&&(r+=`
+         ${c("\u2192 "+e.suggestion,"cyan",t)}`),r}function te(e,t){let n=t.colors!==false,s=[];for(let i of e.files)if(!(i.issues.length===0&&!t.verbose)){if(s.push(""),s.push(c(i.filePath,"bold",n)),i.issues.length===0){s.push(c("  No issues found","green",n));continue}for(let r of i.issues)s.push(ee(r,n));}if(!t.quiet){s.push("");let{errors:i,warnings:r,totalTables:a}=e.summary;if(i===0&&r===0)s.push(c(`\u2713 ${a} tables validated, no issues found`,"green",n));else {let o=[];o.push(`${a} tables validated`),r>0&&o.push(c(`${r} warning${r>1?"s":""}`,"yellow",n)),i>0&&o.push(c(`${i} error${i>1?"s":""}`,"red",n)),s.push(o.join(", "));}s.push(c(`Completed in ${e.durationMs}ms`,"dim",n));}return s.join(`
+`)}function ne(e){return JSON.stringify({passed:e.passed,summary:e.summary,files:e.files.map(t=>({filePath:t.filePath,tables:t.tables,columns:t.columns,issues:t.issues})),durationMs:e.durationMs},null,2)}function se(e){let t=[];for(let r of e.files)for(let a of r.issues){let o=a.severity==="error"?"error":"warning",l=`[${a.rule}]`,u=a.filePath,p=a.line??1,m=`::${o} file=${u},line=${p},title=${l}::${a.message}`;a.suggestion&&(m+=` (${a.suggestion})`),t.push(m);}let{errors:n,warnings:s,totalTables:i}=e.summary;return n>0||s>0?t.push(`::notice::Schema lint: ${i} tables, ${n} errors, ${s} warnings`):t.push(`::notice::Schema lint: ${i} tables validated, no issues`),t.join(`
+`)}function _(e,t){switch(t.format){case "json":return ne(e);case "github":return se(e);default:return te(e,t)}}function re(e,t){let n={format:e,quiet:t?.quiet??false,verbose:t?.verbose??false,colors:t?.colors??true};return s=>_(s,n)}function ie(e,t){let n=_(e,t);console.log(n);}export{L as DEFAULT_LINT_RULES,C as SchemaLinter,g as allRules,v as columnNamingRule,b as conventionRules,E as createLinter,re as createReporter,y as findSchemaFiles,_ as formatLintResult,Z as getAllRuleNames,M as getRuleByName,$ as indexForeignKeysRule,X as lintSchemas,h as loadSchemaFile,R as namingRules,N as noCascadeDeleteRule,F as parseRawTable,S as parseSchemaModule,P as preferUuidPkRule,ie as printLintResult,T as requirePrimaryKeyRule,D as requireSoftDeleteRule,k as requireTimestampsRule,x as securityRules,w as tableNamingRule};