plugin-sensitive-filter-xr 0.0.1 → 0.0.2

package/README.md

@@ -39,13 +39,18 @@ type GeneralPackConfig = {
 };
 
 type SensitiveFilterConfig = {
-  rules?: Array<Partial<SensitiveRule> | null>; // 允许空，支持仅通用规则包
+  rules: Array<Partial<SensitiveRule> | null>; // 必填，且至少 1 条业务规则
   generalPack?: GeneralPackConfig;
   caseSensitive?: boolean;    // default false
   normalize?: boolean;        // default true
 };
 ```
 
+业务规则字段约束：
+- 必填：`pattern`、`type`、`action`
+- 条件必填：当 `action='rewrite'` 时，`replacementText` 必填
+- 可选：`id`（留空自动生成）、`scope`（默认 `both`）、`severity`（默认 `medium`）
+
 ## 通用规则包（General Pack）
 
 - `enabled=false`：不启用通用规则

package/dist/lib/sensitiveFilter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sensitiveFilter.d.ts","sourceRoot":"","sources":["../../src/lib/sensitiveFilter.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAA;AAEvD,OAAO,EACL,eAAe,EAEf,uBAAuB,EACvB,wBAAwB,EACxB,cAAc,EACf,MAAM,sBAAsB,CAAA;AAC7B,OAAO,EAGL,qBAAqB,EAKtB,MAAM,YAAY,CAAA;AAuQnB,qBAEa,yBAA0B,YAAW,wBAAwB,CAAC,qBAAqB,CAAC;IAC/F,QAAQ,CAAC,IAAI,EAAE,oBAAoB,CA4IlC;IAED,gBAAgB,CACd,OAAO,EAAE,qBAAqB,EAC9B,QAAQ,EAAE,uBAAuB,GAChC,cAAc,CAAC,eAAe,CAAC;CA4GnC;AAED,YAAY,EAAE,qBAAqB,EAAE,CAAA"}
+{"version":3,"file":"sensitiveFilter.d.ts","sourceRoot":"","sources":["../../src/lib/sensitiveFilter.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAA;AAEvD,OAAO,EACL,eAAe,EAEf,uBAAuB,EACvB,wBAAwB,EACxB,cAAc,EACf,MAAM,sBAAsB,CAAA;AAC7B,OAAO,EAGL,qBAAqB,EAKtB,MAAM,YAAY,CAAA;AA6QnB,qBAEa,yBAA0B,YAAW,wBAAwB,CAAC,qBAAqB,CAAC;IAC/F,QAAQ,CAAC,IAAI,EAAE,oBAAoB,CAgKlC;IAED,gBAAgB,CACd,OAAO,EAAE,qBAAqB,EAC9B,QAAQ,EAAE,uBAAuB,GAChC,cAAc,CAAC,eAAe,CAAC;CA4GnC;AAED,YAAY,EAAE,qBAAqB,EAAE,CAAA"}

package/dist/lib/sensitiveFilter.js

@@ -166,9 +166,9 @@ function rewriteModelRequestInput(request, rewrittenText) {
 }
 function normalizeRuleDrafts(input) {
     const rules = [];
-    for (const draft of input) {
+    for (const [index, draft] of input.entries()) {
         if (!isRecord(draft)) {
-            continue;
+            throw new Error(`Invalid rule at index ${index}: rule must be an object`);
         }
         const id = toNonEmptyString(draft['id']);
         const pattern = toNonEmptyString(draft['pattern']);
@@ -177,31 +177,38 @@ function normalizeRuleDrafts(input) {
         const severity = toNonEmptyString(draft['severity']);
         const action = toNonEmptyString(draft['action']);
         const replacementText = toNonEmptyString(draft['replacementText']) ?? undefined;
-        const hasAnyValue = Boolean(id || pattern || type || scope || severity || action || replacementText);
-        if (!hasAnyValue) {
-            continue;
+        if (!pattern) {
+            throw new Error(`Invalid rule at index ${index}: pattern is required`);
         }
-        if (!id || !pattern || !type || !scope || !severity || !action) {
-            continue;
+        if (!type) {
+            throw new Error(`Invalid rule at index ${index}: type is required`);
+        }
+        if (!action) {
+            throw new Error(`Invalid rule at index ${index}: action is required`);
+        }
+        if (action === 'rewrite' && !replacementText) {
+            throw new Error(`Invalid rule at index ${index}: replacementText is required when action is rewrite`);
         }
         if (!['keyword', 'regex'].includes(type)) {
-            continue;
+            throw new Error(`Invalid rule at index ${index}: unsupported type '${type}'`);
         }
-        if (!['input', 'output', 'both'].includes(scope)) {
-            continue;
+        const normalizedScope = scope ?? 'both';
+        if (!['input', 'output', 'both'].includes(normalizedScope)) {
+            throw new Error(`Invalid rule at index ${index}: unsupported scope '${normalizedScope}'`);
         }
-        if (!['high', 'medium'].includes(severity)) {
-            continue;
+        const normalizedSeverity = severity ?? 'medium';
+        if (!['high', 'medium'].includes(normalizedSeverity)) {
+            throw new Error(`Invalid rule at index ${index}: unsupported severity '${normalizedSeverity}'`);
         }
         if (!['block', 'rewrite'].includes(action)) {
-            continue;
+            throw new Error(`Invalid rule at index ${index}: unsupported action '${action}'`);
         }
         rules.push({
-            id,
+            id: id ?? `rule-${index + 1}`,
             pattern,
             type,
-            scope,
-            severity,
+            scope: normalizedScope,
+            severity: normalizedSeverity,
             action,
             replacementText,
         });
@@ -243,6 +250,10 @@ let SensitiveFilterMiddleware = class SensitiveFilterMiddleware {
                                 id: {
                                     type: 'string',
                                     title: { en_US: 'Rule ID', zh_Hans: '规则标识' },
+                                    description: {
+                                        en_US: 'Optional. Auto-generated when empty.',
+                                        zh_Hans: '可选。留空时系统自动生成。',
+                                    },
                                 },
                                 pattern: {
                                     type: 'string',
@@ -295,10 +306,26 @@ let SensitiveFilterMiddleware = class SensitiveFilterMiddleware {
                                 },
                                 replacementText: {
                                     type: 'string',
-                                    title: { en_US: 'Replacement Text', zh_Hans: '替换文本（可选）' },
+                                    title: { en_US: 'Replacement Text', zh_Hans: '替换文本（rewrite 必填）' },
                                 },
                             },
+                            required: ['pattern', 'type', 'action'],
+                            allOf: [
+                                {
+                                    if: {
+                                        properties: {
+                                            action: {
+                                                const: 'rewrite',
+                                            },
+                                        },
+                                    },
+                                    then: {
+                                        required: ['replacementText'],
+                                    },
+                                },
+                            ],
                         },
+                        minItems: 1,
                     },
                     generalPack: {
                         type: 'object',
@@ -356,7 +383,7 @@ let SensitiveFilterMiddleware = class SensitiveFilterMiddleware {
         const config = parsed.data;
         const caseSensitive = config.caseSensitive ?? false;
         const normalize = config.normalize ?? true;
-        const customRules = normalizeRuleDrafts(config.rules ?? []);
+        const customRules = normalizeRuleDrafts(config.rules);
         const generalRules = resolveGeneralPackRules(config.generalPack);
         const allRules = [...customRules, ...generalRules];
         const compiledRules = allRules.map((rule, index) => {

package/dist/lib/types.d.ts

@@ -13,7 +13,7 @@ export type GeneralPackConfig = {
     profile?: 'strict' | 'balanced';
 };
 export type SensitiveFilterConfig = {
-    rules?: Array<Partial<SensitiveRule> | null>;
+    rules: Array<Partial<SensitiveRule> | null>;
     generalPack?: GeneralPackConfig;
     caseSensitive?: boolean;
     normalize?: boolean;
@@ -26,13 +26,13 @@ export type CompiledSensitiveRule = SensitiveRule & {
 };
 export declare const SensitiveFilterIcon = "<svg width=\"800px\" height=\"800px\" viewBox=\"0 0 24 24\" xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M12 2l7 3v6c0 5.2-3.3 9.9-7 11-3.7-1.1-7-5.8-7-11V5l7-3zm0 2.1L7 6v5c0 3.9 2.3 7.8 5 8.9 2.7-1.1 5-5 5-8.9V6l-5-1.9zM8.8 12.6l1.4-1.4 1.8 1.8 3.8-3.8 1.4 1.4-5.2 5.2-3.2-3.2z\"/></svg>";
 export declare const sensitiveFilterConfigSchema: z.ZodObject<{
-    rules: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodNullable<z.ZodObject<{
+    rules: z.ZodArray<z.ZodNullable<z.ZodEffects<z.ZodObject<{
         id: z.ZodNullable<z.ZodOptional<z.ZodString>>;
-        pattern: z.ZodNullable<z.ZodOptional<z.ZodString>>;
-        type: z.ZodNullable<z.ZodOptional<z.ZodEnum<["keyword", "regex"]>>>;
+        pattern: z.ZodString;
+        type: z.ZodEnum<["keyword", "regex"]>;
         scope: z.ZodNullable<z.ZodOptional<z.ZodEnum<["input", "output", "both"]>>>;
         severity: z.ZodNullable<z.ZodOptional<z.ZodEnum<["high", "medium"]>>>;
-        action: z.ZodNullable<z.ZodOptional<z.ZodEnum<["block", "rewrite"]>>>;
+        action: z.ZodEnum<["block", "rewrite"]>;
         replacementText: z.ZodNullable<z.ZodOptional<z.ZodString>>;
     }, "strip", z.ZodTypeAny, {
         id?: string;
@@ -50,7 +50,23 @@ export declare const sensitiveFilterConfigSchema: z.ZodObject<{
         severity?: "high" | "medium";
         action?: "block" | "rewrite";
         replacementText?: string;
-    }>>, "many">>>;
+    }>, {
+        id?: string;
+        pattern?: string;
+        type?: "keyword" | "regex";
+        scope?: "input" | "output" | "both";
+        severity?: "high" | "medium";
+        action?: "block" | "rewrite";
+        replacementText?: string;
+    }, {
+        id?: string;
+        pattern?: string;
+        type?: "keyword" | "regex";
+        scope?: "input" | "output" | "both";
+        severity?: "high" | "medium";
+        action?: "block" | "rewrite";
+        replacementText?: string;
+    }>>, "many">;
     generalPack: z.ZodOptional<z.ZodObject<{
         enabled: z.ZodDefault<z.ZodBoolean>;
         profile: z.ZodOptional<z.ZodDefault<z.ZodEnum<["strict", "balanced"]>>>;

package/dist/lib/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/lib/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAE1B,MAAM,MAAM,aAAa,GAAG;IAC1B,EAAE,EAAE,MAAM,CAAA;IACV,OAAO,EAAE,MAAM,CAAA;IACf,IAAI,EAAE,SAAS,GAAG,OAAO,CAAA;IACzB,KAAK,EAAE,OAAO,GAAG,QAAQ,GAAG,MAAM,CAAA;IAClC,QAAQ,EAAE,MAAM,GAAG,QAAQ,CAAA;IAC3B,MAAM,EAAE,OAAO,GAAG,SAAS,CAAA;IAC3B,eAAe,CAAC,EAAE,MAAM,CAAA;CACzB,CAAA;AAED,MAAM,MAAM,iBAAiB,GAAG;IAC9B,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,OAAO,CAAC,EAAE,QAAQ,GAAG,UAAU,CAAA;CAChC,CAAA;AAED,MAAM,MAAM,qBAAqB,GAAG;IAClC,KAAK,CAAC,EAAE,KAAK,CAAC,OAAO,CAAC,aAAa,CAAC,GAAG,IAAI,CAAC,CAAA;IAC5C,WAAW,CAAC,EAAE,iBAAiB,CAAA;IAC/B,aAAa,CAAC,EAAE,OAAO,CAAA;IACvB,SAAS,CAAC,EAAE,OAAO,CAAA;CACpB,CAAA;AAED,MAAM,MAAM,qBAAqB,GAAG,aAAa,GAAG;IAClD,KAAK,EAAE,MAAM,CAAA;IACb,iBAAiB,EAAE,MAAM,CAAA;IACzB,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,YAAY,CAAC,EAAE,MAAM,CAAA;CACtB,CAAA;AAED,eAAO,MAAM,mBAAmB,wSAA8R,CAAA;AAmC9T,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAKtC,CAAA;AAYF,wBAAgB,uBAAuB,CAAC,MAAM,CAAC,EAAE,iBAAiB,GAAG,aAAa,EAAE,CA6CnF"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/lib/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAE1B,MAAM,MAAM,aAAa,GAAG;IAC1B,EAAE,EAAE,MAAM,CAAA;IACV,OAAO,EAAE,MAAM,CAAA;IACf,IAAI,EAAE,SAAS,GAAG,OAAO,CAAA;IACzB,KAAK,EAAE,OAAO,GAAG,QAAQ,GAAG,MAAM,CAAA;IAClC,QAAQ,EAAE,MAAM,GAAG,QAAQ,CAAA;IAC3B,MAAM,EAAE,OAAO,GAAG,SAAS,CAAA;IAC3B,eAAe,CAAC,EAAE,MAAM,CAAA;CACzB,CAAA;AAED,MAAM,MAAM,iBAAiB,GAAG;IAC9B,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,OAAO,CAAC,EAAE,QAAQ,GAAG,UAAU,CAAA;CAChC,CAAA;AAED,MAAM,MAAM,qBAAqB,GAAG;IAClC,KAAK,EAAE,KAAK,CAAC,OAAO,CAAC,aAAa,CAAC,GAAG,IAAI,CAAC,CAAA;IAC3C,WAAW,CAAC,EAAE,iBAAiB,CAAA;IAC/B,aAAa,CAAC,EAAE,OAAO,CAAA;IACvB,SAAS,CAAC,EAAE,OAAO,CAAA;CACpB,CAAA;AAED,MAAM,MAAM,qBAAqB,GAAG,aAAa,GAAG;IAClD,KAAK,EAAE,MAAM,CAAA;IACb,iBAAiB,EAAE,MAAM,CAAA;IACzB,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,YAAY,CAAC,EAAE,MAAM,CAAA;CACtB,CAAA;AAED,eAAO,MAAM,mBAAmB,wSAA8R,CAAA;AAoD9T,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAKtC,CAAA;AAYF,wBAAgB,uBAAuB,CAAC,MAAM,CAAC,EAAE,iBAAiB,GAAG,aAAa,EAAE,CA6CnF"}

package/dist/lib/types.js

@@ -18,12 +18,28 @@ const OPEN_SOURCE_LEXICON = {
 const sensitiveRuleDraftSchema = z
     .object({
     id: z.string().optional().nullable(),
-    pattern: z.string().optional().nullable(),
-    type: z.enum(['keyword', 'regex']).optional().nullable(),
+    pattern: z.string(),
+    type: z.enum(['keyword', 'regex']),
     scope: z.enum(['input', 'output', 'both']).optional().nullable(),
     severity: z.enum(['high', 'medium']).optional().nullable(),
-    action: z.enum(['block', 'rewrite']).optional().nullable(),
+    action: z.enum(['block', 'rewrite']),
     replacementText: z.string().optional().nullable(),
+})
+    .superRefine((value, ctx) => {
+    if (!value.pattern?.trim()) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ['pattern'],
+            message: 'pattern is required',
+        });
+    }
+    if (value.action === 'rewrite' && !value.replacementText?.trim()) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ['replacementText'],
+            message: 'replacementText is required when action is rewrite',
+        });
+    }
 })
     .nullable();
 const generalPackSchema = z.object({
@@ -31,7 +47,7 @@ const generalPackSchema = z.object({
     profile: z.enum(['strict', 'balanced']).default('balanced').optional(),
 });
 export const sensitiveFilterConfigSchema = z.object({
-    rules: z.array(sensitiveRuleDraftSchema).optional().default([]),
+    rules: z.array(sensitiveRuleDraftSchema).min(1, 'at least one business rule is required'),
     generalPack: generalPackSchema.optional(),
     caseSensitive: z.boolean().optional().default(false),
     normalize: z.boolean().optional().default(true),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "plugin-sensitive-filter-xr",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "author": {
     "name": "XpertAI",
     "url": "https://xpertai.cn"