@autobe/agent
Version:
AI backend server code generator
705 lines (646 loc) • 35.1 kB
JavaScript
;
Object.defineProperty(exports, "__esModule", { value: true });
exports.AutoBeJsonSchemaValidator = void 0;
const utils_1 = require("@autobe/utils");
const utils_2 = require("@typia/utils");
const AutoBeJsonSchemaFactory_1 = require("./AutoBeJsonSchemaFactory");
var AutoBeJsonSchemaValidator;
(function (AutoBeJsonSchemaValidator) {
AutoBeJsonSchemaValidator.isObjectType = (props) => props.typeName.endsWith(".IAuthorized") ||
props.typeName.endsWith(".IRequest") ||
props.typeName.endsWith(".ISummary") ||
props.typeName.endsWith(".IInvert") ||
props.typeName.endsWith(".ICreate") ||
props.typeName.endsWith(".IUpdate") ||
props.typeName.endsWith(".IJoin") ||
props.typeName.endsWith(".ILogin") ||
props.operations.some((op) => {
var _a, _b;
return ((_a = op.requestBody) === null || _a === void 0 ? void 0 : _a.typeName) === props.typeName ||
((_b = op.responseBody) === null || _b === void 0 ? void 0 : _b.typeName) === props.typeName;
});
AutoBeJsonSchemaValidator.isPage = (key) => key.startsWith("IPage") === true &&
key.startsWith("IPage.") === false &&
key !== "IPage";
AutoBeJsonSchemaValidator.isPreset = (typeName) => AutoBeJsonSchemaFactory_1.AutoBeJsonSchemaFactory.DEFAULT_SCHEMAS[typeName] !== undefined ||
AutoBeJsonSchemaValidator.isPage(typeName) === true;
AutoBeJsonSchemaValidator.validateSchema = (props) => {
const vo = validateObjectType({
errors: props.errors,
operations: props.operations,
path: props.path,
});
validateAuthorization(props);
validateRecursive(props);
validateReferenceId(props);
validatePropertyNames(props);
validateNumericRanges(props);
validatePaginationVariant(props);
// validateEmptyProperties(props);
vo(props.typeName, props.schema);
utils_1.AutoBeOpenApiTypeChecker.skim({
schema: props.schema,
closure: (next, accessor) => {
if (utils_1.AutoBeOpenApiTypeChecker.isReference(next) === false)
return;
const key = next.$ref.split("/").pop();
AutoBeJsonSchemaValidator.validateKey({
errors: props.errors,
path: `${accessor}.$ref`,
key,
transform: (typeName) => `#/components/schemas/${typeName}`,
});
},
accessor: props.path,
});
};
AutoBeJsonSchemaValidator.validateKey = (props) => {
var _a;
const transform = (_a = props.transform) !== null && _a !== void 0 ? _a : ((typeName) => typeName);
const elements = props.key.split(".");
if (elements.length > 2)
props.errors.push({
path: props.path,
expected: "At most one dot(.) character allowed in type name",
value: transform(props.key),
description: utils_1.StringUtil.trim `
JSON schema type name allows at most one dot(.) character to separate
module name and interface name.
However, current key name ${transform(JSON.stringify(props.key))}
contains multiple dot(.) characters (${elements.length - 1} times).
Change it to a valid type name with at most one dot(.) character at the next time.
Note that, this is not a recommendation, but an instruction you must follow.
`,
});
if (elements.every(utils_2.NamingConvention.variable) === false)
props.errors.push({
path: props.path,
expected: utils_1.StringUtil.trim `
Valid variable name
${elements.map((s) => `- ${s}: ${utils_2.NamingConvention.variable(s) ? "valid" : "invalid"}`).join("\n")}
`,
value: transform(props.key),
description: utils_1.StringUtil.trim `
JSON schema type name must be a valid variable name.
Even though JSON schema type name allows dot(.) character, but
each segment separated by dot(.) must be a valid variable name.
Current key name ${transform(JSON.stringify(props.key))} is not valid.
Change it to a valid variable name at the next time.
Note that, this is not a recommendation, but an instruction you must follow.
`,
});
if (props.key.endsWith(".IPage")) {
const expected = `IPage${props.key.substring(0, props.key.length - 6)}`;
props.errors.push({
path: props.path,
expected: `"IPage" must be followed by another interface name. Use ${transform(JSON.stringify(expected))} instead.`,
value: transform(props.key),
description: utils_1.StringUtil.trim `
"IPage" is a reserved type name for pagination response.
The pagination data type name must be post-fixed after "IPage".
However, you've defined ${transform(JSON.stringify(props.key))},
post-fixing ".IPage" after the pagination data type name.
Change it to a valid pagination type name to be
${transform(JSON.stringify(expected))} at the next time.
Note that, this is not a recommendation, but an instruction you must follow.
`,
});
}
if (props.key === "IPageIRequest")
props.errors.push({
path: props.path,
expected: `"IPageIRequest" is a mistake. Use "IPage.IRequest" instead.`,
value: transform(props.key),
description: utils_1.StringUtil.trim `
You've taken a mistake that defines "${transform("IPageIRequest")}" as a type name.
However, as you've intended to define a pagination request type,
the correct type name is "${transform("IPage.IRequest")}" instead of "${transform("IPageIRequest")}".
Change it to "${transform("IPage.IRequest")}" at the next time.
Note that, this is not a recommendation, but an instruction you must follow.
`,
});
if (props.key.startsWith("IPage") &&
props.key.startsWith("IPageI") === false &&
props.key !== "IPage.IPagination" &&
props.key !== "IPage.IRequest") {
const expected = `IPage${props.key
.substring(5)
.split(".")
.map((s) => (s.startsWith("I") ? s : `I${s}`))
.join(".")}`;
props.errors.push({
path: props.path,
expected: `Interface name starting with 'I' even after 'IPage': ${JSON.stringify(expected)}`,
value: transform(props.key),
description: utils_1.StringUtil.trim `
JSON schema type name must be an interface name starting with 'I'.
Even though JSON schema type name allows dot(.) character, but
each segment separated by dot(.) must be an interface name starting
with 'I'.
Even in the case of pagination response, after 'IPage' prefix,
the remaining part must be an interface name starting with 'I'.
Current key name ${JSON.stringify(props.key)} is not valid. Change
it to a valid interface name to be ${JSON.stringify(expected)},
or change it to another valid interface name at the next time.
Note that, this is not a recommendation, but an instruction you must follow.
`,
});
}
if (elements.some((s) => s.startsWith("I") === false) === true) {
const expected = elements
.map((s) => (s.startsWith("I") ? s : `I${s}`))
.join(".");
props.errors.push({
path: props.path,
expected: `Interface name starting with 'I': ${JSON.stringify(expected)}`,
value: transform(props.key),
description: utils_1.StringUtil.trim `
JSON schema type name must be an interface name starting with 'I'.
Even though JSON schema type name allows dot(.) character, but
each segment separated by dot(.) must be an interface name starting
with 'I'.
Current key name ${transform(JSON.stringify(props.key))} is not valid.
Change it to a valid interface name to be ${transform(JSON.stringify(expected))},
or change it to another valid interface name at the next time.
Note that, this is not a recommendation, but an instruction you must follow.
`,
});
}
if (elements.length === 2 &&
(elements[1] === "IJoin" ||
elements[1] === "ILogin" ||
elements[1] === "IAuthorized" ||
elements[1] === "IRefresh") &&
elements[0].endsWith("Session") === true)
props.errors.push({
path: props.path,
expected: JSON.stringify(`${elements[0].replace("Session", "")}.${elements[1]}`),
value: transform(props.key),
description: utils_1.StringUtil.trim `
You have attached ${elements[1]} to a Session type ${transform(JSON.stringify(props.key))},
but this is architecturally incorrect.
In production authentication systems, Actor and Session are separate concepts:
- **Actor** (e.g., User, Seller, Admin): The persistent user identity that performs
authentication actions - joining (registering), logging in, and receiving authorized tokens.
- **Session** (e.g., UserSession, SellerSession): The temporary authentication state that
tracks active login instances. Sessions are CREATED as a result of join/login operations,
but they do not perform these actions themselves.
Think about it semantically: An ACTOR joins the system and logs in. A SESSION is merely
a record that gets created when the actor authenticates. It makes no sense for a session
to "join" or "login" - only actors do that.
Therefore, authentication-related DTO types (IJoin, ILogin, IAuthorized, IRefresh) MUST
be attached to the Actor type, NEVER to the Session type.
Change ${transform(JSON.stringify(props.key))} to ${transform(JSON.stringify(`${elements[0].replace("Session", "")}.${elements[1]}`))} at the next time.
Note that, this is not a recommendation, but an instruction you must follow.
`,
});
};
const validateAuthorization = (props) => {
var _a, _b;
var _c, _d;
if (props.typeName.endsWith(".IAuthorized") === true) {
if (utils_1.AutoBeOpenApiTypeChecker.isObject(props.schema) === false) {
props.errors.push({
path: props.path,
expected: `AutoBeOpenApi.IJsonSchemaDescriptive<AutoBeOpenApi.IJsonSchema.IObject>`,
value: props.schema,
description: `${props.typeName} must be an object type for authorization responses. Note that, this is not a recommendation, but an instruction you must follow.`,
});
}
else {
// Check if token property exists
(_a = (_c = props.schema).properties) !== null && _a !== void 0 ? _a : (_c.properties = {});
props.schema.properties["token"] = {
"x-autobe-specification": "JWT token information for authentication. Server generates this token upon successful login/join.",
description: "JWT token information for authentication.",
$ref: "#/components/schemas/IAuthorizationToken",
};
(_b = (_d = props.schema).required) !== null && _b !== void 0 ? _b : (_d.required = []);
if (props.schema.required.includes("token") === false)
props.schema.required.push("token");
}
}
utils_1.AutoBeOpenApiTypeChecker.skim({
schema: props.schema,
accessor: props.path,
closure: (next, accessor) => {
if (utils_1.AutoBeOpenApiTypeChecker.isReference(next) === false)
return;
const key = next.$ref.split("/").pop();
if (key.endsWith(".IAuthorized") === false &&
key.endsWith(".ILogin") === false &&
key.endsWith(".IJoin") === false)
return;
const candidates = new Set(props.operations
.map((op) => {
var _a, _b;
return [
((_a = op.requestBody) === null || _a === void 0 ? void 0 : _a.typeName.endsWith(key.split(".").pop()))
? op.requestBody.typeName
: null,
((_b = op.responseBody) === null || _b === void 0 ? void 0 : _b.typeName.endsWith(key.split(".").pop()))
? op.responseBody.typeName
: null,
];
})
.flat()
.filter((v) => v !== null));
if (candidates.has(key) === false)
props.errors.push({
path: `${accessor}.$ref`,
expected: Array.from(candidates)
.map((s) => JSON.stringify(`#/components/schemas/${s}`))
.join(" | "),
value: key,
description: utils_1.StringUtil.trim `
You've referenced an authorization-related type ${JSON.stringify(key)}
that is not used in any operation's requestBody or responseBody.
Authorization-related types must be used in at least one operation's
requestBody or responseBody. Make sure to use the type appropriately
in your API design.
Existing authorization-related types used in operations are:
- ${Array.from(candidates)
.map((s) => `#/components/schemas/${s}`)
.join("\n- ")}
Note that, this is not a recommendation, but an instruction you must follow.
`,
});
},
});
};
const validateRecursive = (props) => {
const report = (description) => props.errors.push({
path: props.path,
expected: "Non-infinite recursive schema definition",
value: props.schema,
description,
});
if (utils_1.AutoBeOpenApiTypeChecker.isReference(props.schema) &&
props.schema.$ref === `#/components/schemas/${props.typeName}`)
report(utils_1.StringUtil.trim `
You have defined a nonsensible type like below:
\`\`\`typescript
type ${props.typeName} = ${props.typeName};
\`\`\`
This is an infinite recursive type definition that cannot exist in any
programming language. A type cannot be defined as itself - this creates
a circular definition with no base case, making the type impossible to
instantiate or validate.
If you need tree or graph structures, use explicit relationships with
ID references (e.g., parentId: string) instead of recursive type definitions.
Remove the self-reference and redesign the schema at the next time.
Note that, this is not a recommendation, but an instruction you must follow.
`);
else if (utils_1.AutoBeOpenApiTypeChecker.isArray(props.schema) &&
utils_1.AutoBeOpenApiTypeChecker.isReference(props.schema.items) &&
props.schema.items.$ref === `#/components/schemas/${props.typeName}`)
report(utils_1.StringUtil.trim `
You have defined a nonsensible type like below:
\`\`\`typescript
type ${props.typeName} = Array<${props.typeName}>;
\`\`\`
This is an infinite recursive array type that cannot exist in any
programming language. An array of itself creates a circular definition
with no base case, making the type impossible to instantiate or validate.
If you need nested structures, define explicit depth levels with separate
types, or use parent-child relationships with ID references.
Remove the self-reference and redesign the schema at the next time.
Note that, this is not a recommendation, but an instruction you must follow.
`);
else if (utils_1.AutoBeOpenApiTypeChecker.isOneOf(props.schema) &&
props.schema.oneOf.some((v) => utils_1.AutoBeOpenApiTypeChecker.isReference(v) &&
v.$ref === `#/components/schemas/${props.typeName}`) === true)
report(utils_1.StringUtil.trim `
You have defined a nonsensible type like below:
\`\`\`typescript
type ${props.typeName} = ${props.typeName} | ...;
\`\`\`
This is an infinite recursive union type that cannot exist in any
programming language. A union that includes itself as a variant creates
a circular definition with no base case, making the type impossible to
instantiate or validate.
If you need polymorphic hierarchies, define separate concrete types for
each variant without including the union type itself as a variant.
Remove the self-reference and redesign the schema at the next time.
Note that, this is not a recommendation, but an instruction you must follow.
`);
else if (utils_1.AutoBeOpenApiTypeChecker.isObject(props.schema) &&
props.schema.properties &&
props.schema.required &&
Object.entries(props.schema.properties).some(([k, v]) => utils_1.AutoBeOpenApiTypeChecker.isReference(v) &&
v.$ref === `#/components/schemas/${props.typeName}` &&
props.schema.required.includes(k)))
report(utils_1.StringUtil.trim `
You have defined a nonsensible type like below:
\`\`\`typescript
interface ${props.typeName} {
someProperty: ${props.typeName}; // required, non-nullable
}
\`\`\`
This is an infinite recursive object type that cannot exist in any
programming language. A required non-nullable property referencing its
own type creates a circular definition with no base case, making the
type impossible to instantiate.
To create an instance of ${props.typeName}, you would need an instance of ${props.typeName},
which requires another instance of ${props.typeName}, infinitely. This is logically
impossible.
If you need parent-child or graph relationships, make the self-referencing
property either nullable or optional, or use ID references (e.g., parentId: string).
Remove the required self-reference and redesign the schema at the next time.
Note that, this is not a recommendation, but an instruction you must follow.
`);
};
const validateObjectType = (props) => {
const root = new Set();
for (const o of props.operations) {
if (o.requestBody)
root.add(o.requestBody.typeName);
if (o.responseBody)
root.add(o.responseBody.typeName);
}
return (key, schema) => {
if (utils_1.AutoBeOpenApiTypeChecker.isObject(schema) === true)
return;
if (root.has(key))
props.errors.push({
path: props.path,
expected: `AutoBeOpenApi.IJsonSchemaDescriptive.IObject`,
value: schema,
description: utils_1.StringUtil.trim `
Root schema types (used in requestBody or responseBody of operations)
must be defined as object types.
This is the rule enforced to ensure consistent API design and to facilitate easier data handling.
Even though you think that defining a non-object type is more convenient for your specific use case,
just follow the rule without any resistance.
Note that, this is not a recommendation, but an instruction you must follow.
If current type is hard to be defined as an object type, just wrap it in an object type like below:
\`\`\`typescript
{
value: T;
}
\`\`\`
`,
});
else if (key.endsWith(".IRequest") ||
key.endsWith(".ISummary") ||
key.endsWith(".IInvert") ||
key.endsWith(".ICreate") ||
key.endsWith(".IUpdate") ||
key.endsWith(".IJoin") ||
key.endsWith(".ILogin") ||
key.endsWith(".IAuthorized"))
props.errors.push({
path: props.path,
expected: `AutoBeOpenApi.IJsonSchemaDescriptive.IObject`,
value: schema,
description: utils_1.StringUtil.trim `
DTO type of .${key.split(".").pop()} suffix must be defined as an object type.
This is the rule enforced to ensure consistent API design and to facilitate easier data handling.
Even though you think that defining a non-object type is more convenient for your specific use case,
just follow the rule without any resistance.
Note that, this is not a recommendation, but an instruction you must follow.
If current type is hard to be defined as an object type, just wrap it in an object type like below:
\`\`\`typescript
{
value: T;
}
\`\`\`
`,
});
};
};
const validateReferenceId = (props) => {
if (utils_1.AutoBeOpenApiTypeChecker.isObject(props.schema) === false)
return;
for (const [key, value] of Object.entries(props.schema.properties)) {
if (key !== "id" && key.endsWith("_id") === false)
continue;
const accessor = `${props.path}.properties${utils_2.NamingConvention.variable(key) ? `.${key}` : `[${JSON.stringify(key)}]`}`;
const inspect = (schema) => utils_1.AutoBeOpenApiTypeChecker.isString(schema) ||
utils_1.AutoBeOpenApiTypeChecker.isNull(schema) ||
(utils_1.AutoBeOpenApiTypeChecker.isOneOf(schema) &&
schema.oneOf.every((v) => inspect(v)));
if (inspect(value) === false)
props.errors.push({
path: accessor,
expected: utils_1.StringUtil.trim `
| { type: "string"; format: "uuid"; description: string; }
| {
oneOf: [
{ type: "string"; format: "uuid"; },
{ type: "null"; },
];
description: string;
}`,
value,
description: utils_1.StringUtil.trim `
Property names "id" or ending with "_id" must be defined as
UUID string type, or nullable UUID string type.
This is the rule enforced to ensure consistent identification of
resources across the API. Even though you think that defining a
different type is more convenient for your specific use case,
just follow the rule without any resistance.
Note that, this is not a recommendation, but an instruction you
must follow.
`,
});
}
};
const validatePropertyNames = (props) => {
if (utils_1.AutoBeOpenApiTypeChecker.isObject(props.schema) === false)
return;
for (const key of Object.keys(props.schema.properties)) {
if (utils_2.NamingConvention.reserved(key))
props.errors.push({
path: `${props.path}.properties${utils_2.NamingConvention.variable(key) ? `.${key}` : `[${JSON.stringify(key)}]`}`,
expected: `none system reserved word`,
value: key,
description: utils_1.StringUtil.trim `
Property name ${JSON.stringify(key)} is a system reserved word.
Avoid using system reserved words as property names to prevent
potential conflicts and ensure clarity in your API design.
Change the property name ${JSON.stringify(key)} to a non-reserved
word at the next time.
Note that, this is not a recommendation, but an instruction you
must follow.
`,
});
else if (utils_2.NamingConvention.variable(key) === false)
props.errors.push({
path: `${props.path}.properties${utils_2.NamingConvention.variable(key) ? `.${key}` : `[${JSON.stringify(key)}]`}`,
expected: `valid variable name`,
value: key,
description: utils_1.StringUtil.trim `
Property name ${JSON.stringify(key)} must be a valid variable name.
Valid variable names start with a letter, underscore (_), or dollar sign ($),
followed by letters, digits, underscores, or dollar signs. They cannot
contain spaces or special characters.
Change the property name ${JSON.stringify(key)} to a valid variable
name at the next time.
Note that, this is not a recommendation, but an instruction you
must follow.
`,
});
}
};
const validateNumericRanges = (props) => {
utils_1.AutoBeOpenApiTypeChecker.skim({
schema: props.schema,
accessor: `${props.path}[${JSON.stringify(props.typeName)}]`,
closure: (schema, accessor) => {
if (utils_1.AutoBeOpenApiTypeChecker.isInteger(schema) === false &&
utils_1.AutoBeOpenApiTypeChecker.isNumber(schema) === false)
return;
const { minimum, maximum, exclusiveMinimum, exclusiveMaximum } = schema;
// Case 1: minimum > maximum
if (minimum !== undefined && maximum !== undefined && minimum > maximum)
props.errors.push({
path: accessor,
expected: "minimum <= maximum",
value: schema,
description: utils_1.StringUtil.trim `
Invalid numeric range: minimum (${minimum}) is greater than maximum (${maximum}).
This creates an impossible range where no value can satisfy both constraints.
Either increase maximum or decrease minimum to create a valid range.
Note that, this is not a recommendation, but an instruction you must follow.
`,
});
// Case 2: exclusiveMinimum >= exclusiveMaximum
if (exclusiveMinimum !== undefined &&
exclusiveMaximum !== undefined &&
exclusiveMinimum >= exclusiveMaximum)
props.errors.push({
path: accessor,
expected: "exclusiveMinimum < exclusiveMaximum",
value: schema,
description: utils_1.StringUtil.trim `
Invalid numeric range: exclusiveMinimum (${exclusiveMinimum}) is greater than
or equal to exclusiveMaximum (${exclusiveMaximum}).
This creates an impossible range where no value can satisfy both constraints.
Either increase exclusiveMaximum or decrease exclusiveMinimum to create a valid range.
Note that, this is not a recommendation, but an instruction you must follow.
`,
});
// Case 3: minimum >= exclusiveMaximum
if (minimum !== undefined &&
exclusiveMaximum !== undefined &&
minimum >= exclusiveMaximum)
props.errors.push({
path: accessor,
expected: "minimum < exclusiveMaximum",
value: schema,
description: utils_1.StringUtil.trim `
Invalid numeric range: minimum (${minimum}) is greater than or equal to
exclusiveMaximum (${exclusiveMaximum}).
This creates an impossible range. A value cannot be >= ${minimum} and < ${exclusiveMaximum}
at the same time when minimum >= exclusiveMaximum.
Either increase exclusiveMaximum or decrease minimum to create a valid range.
Note that, this is not a recommendation, but an instruction you must follow.
`,
});
// Case 4: exclusiveMinimum >= maximum
if (exclusiveMinimum !== undefined &&
maximum !== undefined &&
exclusiveMinimum >= maximum)
props.errors.push({
path: accessor,
expected: "exclusiveMinimum < maximum",
value: schema,
description: utils_1.StringUtil.trim `
Invalid numeric range: exclusiveMinimum (${exclusiveMinimum}) is greater than
or equal to maximum (${maximum}).
This creates an impossible range. A value cannot be > ${exclusiveMinimum} and <= ${maximum}
at the same time when exclusiveMinimum >= maximum.
Either increase maximum or decrease exclusiveMinimum to create a valid range.
Note that, this is not a recommendation, but an instruction you must follow.
`,
});
// Case 5: minimum === maximum with exclusive constraints
if (minimum !== undefined &&
maximum !== undefined &&
minimum === maximum &&
(exclusiveMinimum !== undefined || exclusiveMaximum !== undefined))
props.errors.push({
path: accessor,
expected: "no exclusive constraints when minimum equals maximum",
value: schema,
description: utils_1.StringUtil.trim `
Invalid numeric range: minimum equals maximum (${minimum}), but exclusive
constraints are also defined.
When minimum === maximum, the only valid value is exactly ${minimum}.
Adding exclusiveMinimum or exclusiveMaximum makes this impossible.
Remove the exclusive constraints or adjust minimum/maximum to create a valid range.
Note that, this is not a recommendation, but an instruction you must follow.
`,
});
// Case 6: negative multipleOf
if (schema.multipleOf !== undefined && schema.multipleOf <= 0)
props.errors.push({
path: accessor,
expected: "multipleOf > 0",
value: schema,
description: utils_1.StringUtil.trim `
Invalid multipleOf value: ${schema.multipleOf}.
The multipleOf constraint must be a positive number greater than zero.
Change multipleOf to a positive value.
Note that, this is not a recommendation, but an instruction you must follow.
`,
});
},
});
};
const validatePaginationVariant = (props) => {
// Reject .IPagination variants on entity types (only IPage.IPagination is valid)
if (props.typeName.endsWith(".IPagination") &&
props.typeName !== "IPage.IPagination")
props.errors.push({
path: props.path,
expected: `No .IPagination variant — only "IPage.IPagination" is valid`,
value: props.typeName,
description: utils_1.StringUtil.trim `
You have defined a type ${JSON.stringify(props.typeName)} with an
".IPagination" suffix, but ".IPagination" is NOT a valid DTO variant.
The only valid pagination metadata type is "IPage.IPagination", which is
a system preset containing { current, limit, records, pages }.
Common DTO variants include: .ISummary, .ICreate, .IUpdate, .IRequest,
.IInvert, .IJoin, .ILogin, .IAuthorized.
Remove this type entirely. If you need pagination support, the system
automatically wraps your entity ISummary types in IPage wrappers.
Note that, this is not a recommendation, but an instruction you must follow.
`,
});
};
// const validateEmptyProperties = (props: IProps): void => {
// if (AutoBeOpenApiTypeChecker.isObject(props.schema) === false) return;
// if (Object.keys(props.schema.properties).length !== 0) return;
// if (
// isObjectType({
// operations: props.operations,
// typeName: props.typeName,
// }) === false
// )
// return;
// props.errors.push({
// path: `${props.path}.properties`,
// expected: "At least 1 property in properties",
// value: props.schema.properties,
// description: StringUtil.trim`
// Schema ${JSON.stringify(props.typeName)} has zero properties but is used
// as a request body or response body in API operations.
// Empty properties will cause TypeScript compilation errors (TS2339) in the
// downstream Realize stage because implementation code will try to access
// properties that don't exist on the type.
// You MUST define at least one property in the schema. Load the database
// schema and add the appropriate properties based on the DTO type:
// - ICreate: User-provided business fields (exclude id, timestamps, actor FKs)
// - IUpdate: All mutable business fields (all optional)
// - ISummary: Essential display fields for list views
// - IEntity (root): All public fields including relations
// - IRequest: Pagination and filter parameters
// - IJoin/ILogin: Credentials and session context fields
// Note that, this is not a recommendation, but an instruction you must follow.
// `,
// });
// };
})(AutoBeJsonSchemaValidator || (exports.AutoBeJsonSchemaValidator = AutoBeJsonSchemaValidator = {}));
//# sourceMappingURL=AutoBeJsonSchemaValidator.js.map