@tsofist/schema-forge 2.4.2 → 2.5.0

package/lib/generator/schema-generator.d.ts

@@ -2,6 +2,7 @@ import '../util/patch.extended-annotations-reader';
 import { SchemaObject } from 'ajv';
 import { ChainNodeParser, CompletedConfig, Context, SubNodeParser, TupleType } from 'ts-json-schema-generator';
 import { Node, TupleTypeNode } from 'typescript';
+import { SchemaForgeOptions } from '../types';
 import { TypeExposeKind } from './types';
 interface Options {
     tsconfig: string;
@@ -14,6 +15,7 @@ interface Options {
     openapiCompatible?: boolean;
     sortObjectProperties?: boolean;
     allowUseFallbackDescription?: boolean;
+    shrinkDefinitionNames: SchemaForgeOptions['shrinkDefinitionNames'];
 }
 export declare function generateSchemaByDraftTypes(options: Options): Promise<SchemaObject>;
 export declare class TupleTypeParser implements SubNodeParser {

package/lib/generator/schema-generator.js

@@ -5,6 +5,7 @@ exports.generateSchemaByDraftTypes = generateSchemaByDraftTypes;
 require("../util/patch.extended-annotations-reader");
 const error_1 = require("@tsofist/stem/lib/error");
 const ajv_1 = require("ajv");
+const jsonpath_plus_1 = require("jsonpath-plus");
 const ts_json_schema_generator_1 = require("ts-json-schema-generator");
 const typescript_1 = require("typescript");
 const sort_properties_1 = require("../util/sort-properties");
@@ -54,12 +55,43 @@ async function generateSchemaByDraftTypes(options) {
         const schema = generator.createSchema(definitionName);
         Object.assign(result.definitions, schema.definitions);
     }
+    if (options.shrinkDefinitionNames) {
+        const replacement = new Set();
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+        for (const name of Object.keys(result.definitions)) {
+            console.log('DEF::::', name);
+            const r = options.shrinkDefinitionNames(name);
+            if (r) {
+                if (replacement.has(r) || r in result.definitions) {
+                    (0, error_1.raise)(`Duplicate replacement definition name: ${r}`);
+                }
+                // rename property
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+                result.definitions[r] = result.definitions[name];
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+                delete result.definitions[name];
+                // rename references
+                const targets = (0, jsonpath_plus_1.JSONPath)({
+                    path: `$..[?(@ && @.$ref == "#/definitions/${name}")]`,
+                    json: result,
+                    eval: 'safe',
+                });
+                targets.forEach((item) => {
+                    item.$ref = item.$ref.replace(`#/definitions/${name}`, `#/definitions/${r}`);
+                });
+            }
+        }
+    }
     result.definitions = Object.fromEntries(Object.entries((result.definitions || {})).sort());
     if (options.sortObjectProperties)
         (0, sort_properties_1.sortProperties)(result.definitions);
     await new ajv_1.default({
         strict: true,
         allErrors: true,
+        strictSchema: true,
+        strictTypes: false,
+        strictTuples: false,
+        allowUnionTypes: true,
     }).validateSchema(result, true);
     return result;
 }

package/lib/generator/types.d.ts

@@ -29,7 +29,7 @@ export interface SchemaForgeBaseOptions {
      * Filter for definitions
      * Important: dependencies will not be filtered
      */
-    definitionsFilter?: (name: string) => boolean;
+    readonly definitionsFilter?: (name: string) => boolean;
     /**
      * Create shared $ref definitions for all types
      *

package/lib/generator.js

@@ -3,10 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.forgeSchema = forgeSchema;
 exports.loadJSONSchema = loadJSONSchema;
 exports.loadJSONSchemaSync = loadJSONSchemaSync;
-const fs_1 = require("fs");
-const promises_1 = require("fs/promises");
 const node_crypto_1 = require("node:crypto");
-const promises_2 = require("node:fs/promises");
+const node_fs_1 = require("node:fs");
+const promises_1 = require("node:fs/promises");
 const as_array_1 = require("@tsofist/stem/lib/as-array");
 const error_1 = require("@tsofist/stem/lib/error");
 const noop_1 = require("@tsofist/stem/lib/noop");
@@ -53,6 +52,7 @@ async function forgeSchema(options) {
                         openapiCompatible: options.openapiCompatible,
                         sortObjectProperties: options.sortObjectProperties,
                         allowUseFallbackDescription: options.allowUseFallbackDescription,
+                        shrinkDefinitionNames: options.shrinkDefinitionNames,
                     })),
                     ...(options.schemaMetadata || {}),
                 };
@@ -106,7 +106,7 @@ async function forgeSchema(options) {
         }
         finally {
             if (!KEEP_ARTEFACTS) {
-                await Promise.all(files.map((fileName) => (0, promises_2.unlink)(fileName).catch(noop_1.noop)));
+                await Promise.all(files.map((fileName) => (0, promises_1.unlink)(fileName).catch(noop_1.noop)));
             }
         }
         return {
@@ -118,7 +118,7 @@ async function forgeSchema(options) {
     }
     finally {
         if (tsconfig && tsconfigGenerated) {
-            await (0, promises_2.unlink)(tsconfig).catch(noop_1.noop);
+            await (0, promises_1.unlink)(tsconfig).catch(noop_1.noop);
         }
     }
 }
@@ -127,7 +127,7 @@ async function loadJSONSchema(files) {
 }
 function loadJSONSchemaSync(files) {
     return files.map((fn) => {
-        const content = (0, fs_1.readFileSync)(fn, { encoding: 'utf8' });
+        const content = (0, node_fs_1.readFileSync)(fn, { encoding: 'utf8' });
         return JSON.parse(content);
     });
 }

package/lib/generator.spec.js

@@ -176,6 +176,11 @@ describe('generator for a5', () => {
             outputSchemaMetadataFile,
             expose: 'all',
             explicitPublic: true,
+            shrinkDefinitionNames: (definitionName) => {
+                if (definitionName === 'NamesType')
+                    return 'NT';
+                return undefined;
+            },
         });
         validator = (0, validator_1.createSchemaForgeValidator)({}, true);
         const schema = await (0, generator_1.loadJSONSchema)([outputSchemaFile]);
@@ -195,7 +200,7 @@ describe('generator for a5', () => {
             'DomainNum',
             'DomainValue',
             'DomainValuesType',
-            'NamesType',
+            'NT', // 'NamesType',
             'NamesTypeAbnormal',
             'NumN',
             'Nums',
@@ -205,7 +210,7 @@ describe('generator for a5', () => {
             'VariadicList',
             'VariadicList1',
         ]);
-        expect(validator.getValidator('test#/definitions/NamesType').schema).toStrictEqual({
+        expect(validator.getValidator('test#/definitions/NT').schema).toStrictEqual({
             type: 'string',
             enum: ['v:name1', 'v:name2'],
         });
@@ -217,7 +222,7 @@ describe('generator for a5', () => {
                     $ref: '#/definitions/DomainValuesType',
                 },
                 name0: {
-                    $ref: '#/definitions/NamesType',
+                    $ref: '#/definitions/NT',
                 },
                 name1: {
                     type: 'string',

package/lib/types/db.types.d.ts

@@ -51,6 +51,7 @@ export type DBEntityOptions = {
      * Use string literal to set index name.
      */
     indexes?: {
-        [column: string]: DBIndexOptionsDef<true>;
+        [field: string]: DBIndexOptionsDef<true>;
     };
 };
+export type DBEntityOptionsDef = DBEntityOptions | string;

package/lib/types.d.ts

@@ -1,4 +1,4 @@
-import { Nullable, PRec } from '@tsofist/stem';
+import { NonEmptyString, Nullable, PRec } from '@tsofist/stem';
 import { ErrorCode } from '@tsofist/stem/lib/error';
 import { ErrorObject, ErrorsTextOptions, SchemaObject, ValidateFunction } from 'ajv';
 import { SchemaForgeBaseOptions } from './generator/types';
@@ -73,6 +73,12 @@ export interface SchemaForgeOptions extends SchemaForgeBaseOptions {
      * @default false
      */
     readonly sortObjectProperties?: boolean;
+    /**
+     * If you want to shrink the schema definition names, you have to provide a replacement function.
+     *
+     * WARN: this functionality is not compatible (yet) with `encodeRefs=true` option.
+     */
+    readonly shrinkDefinitionNames?: (definitionName: string) => undefined | NonEmptyString;
 }
 export interface SchemaForgeMetadata {
     $id: string;

package/lib/validator.js

@@ -249,6 +249,7 @@ function createSchemaForgeValidator(engineOptions, useAdditionalFormats = false)
 function addJSDocKeywords(engine) {
     const InterfaceNamePattern = '^[A-Z][a-zA-Z0-9]+$';
     const PropertyNamePattern = '^[a-z][a-zA-Z0-9]+$';
+    const NestedPropertyNamePattern = '^[a-z][a-zA-Z0-9.-]+$';
     const MethodNamePattern = PropertyNamePattern;
     const MemberNamePattern = `${InterfaceNamePattern.substring(0, InterfaceNamePattern.length - 1)}#${PropertyNamePattern.substring(1)}`;
     const IXNamePattern = '^ix_[a-z][a-zA-Z0-9_]+$';
@@ -369,7 +370,7 @@ function addJSDocKeywords(engine) {
                     type: 'object',
                     additionalProperties: DBIndexSchema,
                     propertyNames: {
-                        pattern: PropertyNamePattern,
+                        pattern: NestedPropertyNamePattern,
                     },
                 },
             },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tsofist/schema-forge",
-  "version": "2.4.2",
+  "version": "2.5.0",
   "description": "Generate JSON schema from TypeScript types",
   "author": "Andrew Berdnikov <tsofistgudmen@gmail.com>",
   "license": "LGPL-3.0",
@@ -25,6 +25,7 @@
     "ajv": "^8.17.1",
     "ajv-formats": "^3.0.1",
     "json-schema-faker": "^0.5.8",
+    "jsonpath-plus": "^10.3.0",
     "ts-json-schema-generator": "~2.3.0",
     "tslib": "^2.8.1"
   },