@autobe/agent 0.25.7 → 0.27.0

package/lib/orchestrate/interface/utils/JsonSchemaFactory.js

@@ -84,6 +84,7 @@ var JsonSchemaFactory;
     };
     JsonSchemaFactory.finalize = (props) => {
         removeUnused(props.document);
+        removeDuplicated(props.document);
         fixTimestamps(props);
     };
     const removeUnused = (document) => {
@@ -112,6 +113,46 @@ var JsonSchemaFactory;
             if (used.has(key) === false)
                 delete document.components.schemas[key];
     };
+    const removeDuplicated = (document) => {
+        // gather duplicated schemas
+        const correct = new Map();
+        for (const key of Object.keys(document.components.schemas)) {
+            if (key.includes(".") === false)
+                continue;
+            const dotRemoved = key.replace(".", "");
+            if (document.components.schemas[dotRemoved] === undefined)
+                continue;
+            correct.set(dotRemoved, key);
+        }
+        // fix operations' references
+        for (const op of document.operations) {
+            if (op.requestBody && correct.has(op.requestBody.typeName))
+                op.requestBody.typeName = correct.get(op.requestBody.typeName);
+            if (op.responseBody && correct.has(op.responseBody.typeName))
+                op.responseBody.typeName = correct.get(op.responseBody.typeName);
+        }
+        // fix schemas' references
+        const $refChangers = new Map();
+        for (const value of Object.values(document.components.schemas))
+            openapi_1.OpenApiTypeChecker.visit({
+                components: { schemas: document.components.schemas },
+                schema: value,
+                closure: (next) => {
+                    if (openapi_1.OpenApiTypeChecker.isReference(next) === false)
+                        return;
+                    const x = next.$ref.split("/").pop();
+                    const y = correct.get(x);
+                    if (y === undefined)
+                        return;
+                    $refChangers.set(next, () => (next.$ref = `#/components/schemas/${y}`));
+                },
+            });
+        for (const fn of $refChangers.values())
+            fn();
+        // remove duplicated schemas
+        for (const key of correct.keys())
+            delete document.components.schemas[key];
+    };
     const fixTimestamps = (props) => {
         const entireModels = props.application.files
             .map((f) => f.models)
@@ -182,7 +223,7 @@ var JsonSchemaFactory;
     JsonSchemaFactory.getPageName = (key) => key.substring("IPage".length);
     const isRecord = (input) => typeof input === "object" && input !== null;
 })(JsonSchemaFactory || (exports.JsonSchemaFactory = JsonSchemaFactory = {}));
-const DEFAULT_SCHEMAS = (() => { const _io0 = (input, _exceptionable = true) => Object.keys(input).every(key => {
+const DEFAULT_SCHEMAS = (() => { const _iv1 = new Set(["date-time", "password", "regex", "uuid", "email", "hostname", "idn-email", "idn-hostname", "iri", "iri-reference", "ipv4", "ipv6", "uri", "uri-reference", "uri-template", "url", "date", "time", "duration", "json-pointer", "relative-json-pointer"]); const _iv2 = new Set(["date-time", "password", "regex", "uuid", "email", "hostname", "idn-email", "idn-hostname", "iri", "iri-reference", "ipv4", "ipv6", "uri", "uri-reference", "uri-template", "url", "date", "time", "duration", "json-pointer", "relative-json-pointer"]); const _av7 = new Set(["date-time", "password", "regex", "uuid", "email", "hostname", "idn-email", "idn-hostname", "iri", "iri-reference", "ipv4", "ipv6", "uri", "uri-reference", "uri-template", "url", "date", "time", "duration", "json-pointer", "relative-json-pointer"]); const _av8 = new Set(["date-time", "password", "regex", "uuid", "email", "hostname", "idn-email", "idn-hostname", "iri", "iri-reference", "ipv4", "ipv6", "uri", "uri-reference", "uri-template", "url", "date", "time", "duration", "json-pointer", "relative-json-pointer"]); const _io0 = (input, _exceptionable = true) => Object.keys(input).every(key => {
     const value = input[key];
     if (undefined === value)
         return true;
@@ -215,7 +256,7 @@ const DEFAULT_SCHEMAS = (() => { const _io0 = (input, _exceptionable = true) =>
     if (undefined === value)
         return true;
     return false;
-})); const _io5 = (input, _exceptionable = true) => (undefined === input.format || "string" === typeof input.format) && (undefined === input.pattern || "string" === typeof input.pattern) && (undefined === input.contentMediaType || "string" === typeof input.contentMediaType) && (undefined === input.minLength || "number" === typeof input.minLength && (Math.floor(input.minLength) === input.minLength && 0 <= input.minLength && input.minLength <= 18446744073709552000)) && (undefined === input.maxLength || "number" === typeof input.maxLength && (Math.floor(input.maxLength) === input.maxLength && 0 <= input.maxLength && input.maxLength <= 18446744073709552000)) && "string" === input.type && "string" === typeof input.description && (2 === Object.keys(input).length || Object.keys(input).every(key => {
+})); const _io5 = (input, _exceptionable = true) => (undefined === input.format || true === _iv1.has(input.format)) && (undefined === input.pattern || "string" === typeof input.pattern) && (undefined === input.contentMediaType || "string" === typeof input.contentMediaType) && (undefined === input.minLength || "number" === typeof input.minLength && (Math.floor(input.minLength) === input.minLength && 0 <= input.minLength && input.minLength <= 18446744073709552000)) && (undefined === input.maxLength || "number" === typeof input.maxLength && (Math.floor(input.maxLength) === input.maxLength && 0 <= input.maxLength && input.maxLength <= 18446744073709552000)) && "string" === input.type && "string" === typeof input.description && (2 === Object.keys(input).length || Object.keys(input).every(key => {
     if (["format", "pattern", "contentMediaType", "minLength", "maxLength", "type", "description"].some(prop => key === prop))
         return true;
     const value = input[key];
@@ -243,7 +284,7 @@ const DEFAULT_SCHEMAS = (() => { const _io0 = (input, _exceptionable = true) =>
     if (undefined === value)
         return true;
     return false;
-})); const _io9 = (input, _exceptionable = true) => (undefined === input.format || "string" === typeof input.format) && (undefined === input.pattern || "string" === typeof input.pattern) && (undefined === input.contentMediaType || "string" === typeof input.contentMediaType) && (undefined === input.minLength || "number" === typeof input.minLength && (Math.floor(input.minLength) === input.minLength && 0 <= input.minLength && input.minLength <= 18446744073709552000)) && (undefined === input.maxLength || "number" === typeof input.maxLength && (Math.floor(input.maxLength) === input.maxLength && 0 <= input.maxLength && input.maxLength <= 18446744073709552000)) && "string" === input.type && (1 === Object.keys(input).length || Object.keys(input).every(key => {
+})); const _io9 = (input, _exceptionable = true) => (undefined === input.format || true === _iv2.has(input.format)) && (undefined === input.pattern || "string" === typeof input.pattern) && (undefined === input.contentMediaType || "string" === typeof input.contentMediaType) && (undefined === input.minLength || "number" === typeof input.minLength && (Math.floor(input.minLength) === input.minLength && 0 <= input.minLength && input.minLength <= 18446744073709552000)) && (undefined === input.maxLength || "number" === typeof input.maxLength && (Math.floor(input.maxLength) === input.maxLength && 0 <= input.maxLength && input.maxLength <= 18446744073709552000)) && "string" === input.type && (1 === Object.keys(input).length || Object.keys(input).every(key => {
     if (["format", "pattern", "contentMediaType", "minLength", "maxLength", "type"].some(prop => key === prop))
         return true;
     const value = input[key];
@@ -271,7 +312,7 @@ const DEFAULT_SCHEMAS = (() => { const _io0 = (input, _exceptionable = true) =>
     if (undefined === value)
         return true;
     return false;
-})); const _io13 = (input, _exceptionable = true) => (null === input["x-autobe-prisma-schema"] || undefined === input["x-autobe-prisma-schema"] || "string" === typeof input["x-autobe-prisma-schema"]) && ("object" === typeof input.properties && null !== input.properties && false === Array.isArray(input.properties) && _io0(input.properties, true && _exceptionable)) && (null !== input.additionalProperties && (undefined === input.additionalProperties || false === input.additionalProperties || "object" === typeof input.additionalProperties && null !== input.additionalProperties && _iu2(input.additionalProperties, true && _exceptionable))) && (Array.isArray(input.required) && input.required.every((elem, _index1) => "string" === typeof elem)) && "object" === input.type && (3 === Object.keys(input).length || Object.keys(input).every(key => {
+})); const _io13 = (input, _exceptionable = true) => (null === input["x-autobe-prisma-schema"] || undefined === input["x-autobe-prisma-schema"] || "string" === typeof input["x-autobe-prisma-schema"]) && ("object" === typeof input.properties && null !== input.properties && false === Array.isArray(input.properties) && _io0(input.properties, true && _exceptionable)) && (null !== input.additionalProperties && (undefined === input.additionalProperties || false === input.additionalProperties || "object" === typeof input.additionalProperties && null !== input.additionalProperties && _iu2(input.additionalProperties, true && _exceptionable))) && (Array.isArray(input.required) && input.required.every((elem, _index3) => "string" === typeof elem)) && "object" === input.type && (3 === Object.keys(input).length || Object.keys(input).every(key => {
     if (["x-autobe-prisma-schema", "properties", "additionalProperties", "required", "type"].some(prop => key === prop))
         return true;
     const value = input[key];
@@ -285,7 +326,7 @@ const DEFAULT_SCHEMAS = (() => { const _io0 = (input, _exceptionable = true) =>
     if (undefined === value)
         return true;
     return false;
-})); const _io15 = (input, _exceptionable = true) => Array.isArray(input.oneOf) && input.oneOf.every((elem, _index2) => "object" === typeof elem && null !== elem && _iu0(elem, true && _exceptionable)) && (undefined === input.discriminator || "object" === typeof input.discriminator && null !== input.discriminator && _io17(input.discriminator, true && _exceptionable)) && (1 === Object.keys(input).length || Object.keys(input).every(key => {
+})); const _io15 = (input, _exceptionable = true) => Array.isArray(input.oneOf) && input.oneOf.every((elem, _index4) => "object" === typeof elem && null !== elem && _iu0(elem, true && _exceptionable)) && (undefined === input.discriminator || "object" === typeof input.discriminator && null !== input.discriminator && _io17(input.discriminator, true && _exceptionable)) && (1 === Object.keys(input).length || Object.keys(input).every(key => {
     if (["oneOf", "discriminator"].some(prop => key === prop))
         return true;
     const value = input[key];
@@ -311,7 +352,7 @@ const DEFAULT_SCHEMAS = (() => { const _io0 = (input, _exceptionable = true) =>
     if (undefined === value)
         return true;
     return "string" === typeof value;
-}); const _io19 = (input, _exceptionable = true) => (null === input["x-autobe-prisma-schema"] || undefined === input["x-autobe-prisma-schema"] || "string" === typeof input["x-autobe-prisma-schema"]) && ("object" === typeof input.properties && null !== input.properties && false === Array.isArray(input.properties) && _io0(input.properties, true && _exceptionable)) && (null !== input.additionalProperties && (undefined === input.additionalProperties || false === input.additionalProperties || "object" === typeof input.additionalProperties && null !== input.additionalProperties && _iu2(input.additionalProperties, true && _exceptionable))) && (Array.isArray(input.required) && input.required.every((elem, _index3) => "string" === typeof elem)) && "object" === input.type && "string" === typeof input.description && (4 === Object.keys(input).length || Object.keys(input).every(key => {
+}); const _io19 = (input, _exceptionable = true) => (null === input["x-autobe-prisma-schema"] || undefined === input["x-autobe-prisma-schema"] || "string" === typeof input["x-autobe-prisma-schema"]) && ("object" === typeof input.properties && null !== input.properties && false === Array.isArray(input.properties) && _io0(input.properties, true && _exceptionable)) && (null !== input.additionalProperties && (undefined === input.additionalProperties || false === input.additionalProperties || "object" === typeof input.additionalProperties && null !== input.additionalProperties && _iu2(input.additionalProperties, true && _exceptionable))) && (Array.isArray(input.required) && input.required.every((elem, _index5) => "string" === typeof elem)) && "object" === input.type && "string" === typeof input.description && (4 === Object.keys(input).length || Object.keys(input).every(key => {
     if (["x-autobe-prisma-schema", "properties", "additionalProperties", "required", "type", "description"].some(prop => key === prop))
         return true;
     const value = input[key];
@@ -325,7 +366,7 @@ const DEFAULT_SCHEMAS = (() => { const _io0 = (input, _exceptionable = true) =>
     if (undefined === value)
         return true;
     return false;
-})); const _io21 = (input, _exceptionable = true) => Array.isArray(input.oneOf) && input.oneOf.every((elem, _index4) => "object" === typeof elem && null !== elem && _iu0(elem, true && _exceptionable)) && (undefined === input.discriminator || "object" === typeof input.discriminator && null !== input.discriminator && _io17(input.discriminator, true && _exceptionable)) && "string" === typeof input.description && (2 === Object.keys(input).length || Object.keys(input).every(key => {
+})); const _io21 = (input, _exceptionable = true) => Array.isArray(input.oneOf) && input.oneOf.every((elem, _index6) => "object" === typeof elem && null !== elem && _iu0(elem, true && _exceptionable)) && (undefined === input.discriminator || "object" === typeof input.discriminator && null !== input.discriminator && _io17(input.discriminator, true && _exceptionable)) && "string" === typeof input.description && (2 === Object.keys(input).length || Object.keys(input).every(key => {
     if (["oneOf", "discriminator", "description"].some(prop => key === prop))
         return true;
     const value = input[key];
@@ -584,10 +625,10 @@ const DEFAULT_SCHEMAS = (() => { const _io0 = (input, _exceptionable = true) =>
         expected: "undefined",
         value: value
     }, _errorFactory);
-}))); const _ao5 = (input, _path, _exceptionable = true) => (undefined === input.format || "string" === typeof input.format || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+}))); const _ao5 = (input, _path, _exceptionable = true) => (undefined === input.format || true === _av7.has(input.format) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
     method: "typia.assertEquals",
     path: _path + ".format",
-    expected: "(string | undefined)",
+    expected: "(\"date\" | \"date-time\" | \"duration\" | \"email\" | \"hostname\" | \"idn-email\" | \"idn-hostname\" | \"ipv4\" | \"ipv6\" | \"iri\" | \"iri-reference\" | \"json-pointer\" | \"password\" | \"regex\" | \"relative-json-pointer\" | \"time\" | \"uri\" | \"uri-reference\" | \"uri-template\" | \"url\" | \"uuid\" | undefined)",
     value: input.format
 }, _errorFactory)) && (undefined === input.pattern || "string" === typeof input.pattern || __typia_transform__assertGuard._assertGuard(_exceptionable, {
     method: "typia.assertEquals",
@@ -807,10 +848,10 @@ const DEFAULT_SCHEMAS = (() => { const _io0 = (input, _exceptionable = true) =>
         expected: "undefined",
         value: value
     }, _errorFactory);
-}))); const _ao9 = (input, _path, _exceptionable = true) => (undefined === input.format || "string" === typeof input.format || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+}))); const _ao9 = (input, _path, _exceptionable = true) => (undefined === input.format || true === _av8.has(input.format) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
     method: "typia.assertEquals",
     path: _path + ".format",
-    expected: "(string | undefined)",
+    expected: "(\"date\" | \"date-time\" | \"duration\" | \"email\" | \"hostname\" | \"idn-email\" | \"idn-hostname\" | \"ipv4\" | \"ipv6\" | \"iri\" | \"iri-reference\" | \"json-pointer\" | \"password\" | \"regex\" | \"relative-json-pointer\" | \"time\" | \"uri\" | \"uri-reference\" | \"uri-template\" | \"url\" | \"uuid\" | undefined)",
     value: input.format
 }, _errorFactory)) && (undefined === input.pattern || "string" === typeof input.pattern || __typia_transform__assertGuard._assertGuard(_exceptionable, {
     method: "typia.assertEquals",
@@ -980,9 +1021,9 @@ const DEFAULT_SCHEMAS = (() => { const _io0 = (input, _exceptionable = true) =>
     path: _path + ".required",
     expected: "Array<string>",
     value: input.required
-}, _errorFactory)) && input.required.every((elem, _index5) => "string" === typeof elem || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+}, _errorFactory)) && input.required.every((elem, _index9) => "string" === typeof elem || __typia_transform__assertGuard._assertGuard(_exceptionable, {
     method: "typia.assertEquals",
-    path: _path + ".required[" + _index5 + "]",
+    path: _path + ".required[" + _index9 + "]",
     expected: "string",
     value: elem
 }, _errorFactory)) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
@@ -1029,14 +1070,14 @@ const DEFAULT_SCHEMAS = (() => { const _io0 = (input, _exceptionable = true) =>
     path: _path + ".oneOf",
     expected: "Array<IInteger | INumber | IString | IConstant | IBoolean | IArray | IObject | IReference | INull>",
     value: input.oneOf
-}, _errorFactory)) && input.oneOf.every((elem, _index6) => ("object" === typeof elem && null !== elem || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+}, _errorFactory)) && input.oneOf.every((elem, _index10) => ("object" === typeof elem && null !== elem || __typia_transform__assertGuard._assertGuard(_exceptionable, {
     method: "typia.assertEquals",
-    path: _path + ".oneOf[" + _index6 + "]",
+    path: _path + ".oneOf[" + _index10 + "]",
     expected: "(AutoBeOpenApi.IJsonSchema.IArray | AutoBeOpenApi.IJsonSchema.IBoolean | AutoBeOpenApi.IJsonSchema.IConstant | AutoBeOpenApi.IJsonSchema.IInteger | AutoBeOpenApi.IJsonSchema.INull | AutoBeOpenApi.IJsonSchema.INumber | AutoBeOpenApi.IJsonSchema.IObject | AutoBeOpenApi.IJsonSchema.IReference | AutoBeOpenApi.IJsonSchema.IString)",
     value: elem
-}, _errorFactory)) && _au0(elem, _path + ".oneOf[" + _index6 + "]", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+}, _errorFactory)) && _au0(elem, _path + ".oneOf[" + _index10 + "]", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
     method: "typia.assertEquals",
-    path: _path + ".oneOf[" + _index6 + "]",
+    path: _path + ".oneOf[" + _index10 + "]",
     expected: "(AutoBeOpenApi.IJsonSchema.IArray | AutoBeOpenApi.IJsonSchema.IBoolean | AutoBeOpenApi.IJsonSchema.IConstant | AutoBeOpenApi.IJsonSchema.IInteger | AutoBeOpenApi.IJsonSchema.INull | AutoBeOpenApi.IJsonSchema.INumber | AutoBeOpenApi.IJsonSchema.IObject | AutoBeOpenApi.IJsonSchema.IReference | AutoBeOpenApi.IJsonSchema.IString)",
     value: elem
 }, _errorFactory)) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
@@ -1155,9 +1196,9 @@ const DEFAULT_SCHEMAS = (() => { const _io0 = (input, _exceptionable = true) =>
     path: _path + ".required",
     expected: "Array<string>",
     value: input.required
-}, _errorFactory)) && input.required.every((elem, _index7) => "string" === typeof elem || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+}, _errorFactory)) && input.required.every((elem, _index11) => "string" === typeof elem || __typia_transform__assertGuard._assertGuard(_exceptionable, {
     method: "typia.assertEquals",
-    path: _path + ".required[" + _index7 + "]",
+    path: _path + ".required[" + _index11 + "]",
     expected: "string",
     value: elem
 }, _errorFactory)) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
@@ -1214,14 +1255,14 @@ const DEFAULT_SCHEMAS = (() => { const _io0 = (input, _exceptionable = true) =>
     path: _path + ".oneOf",
     expected: "Array<IInteger | INumber | IString | IConstant | IBoolean | IArray | IObject | IReference | INull>",
     value: input.oneOf
-}, _errorFactory)) && input.oneOf.every((elem, _index8) => ("object" === typeof elem && null !== elem || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+}, _errorFactory)) && input.oneOf.every((elem, _index12) => ("object" === typeof elem && null !== elem || __typia_transform__assertGuard._assertGuard(_exceptionable, {
     method: "typia.assertEquals",
-    path: _path + ".oneOf[" + _index8 + "]",
+    path: _path + ".oneOf[" + _index12 + "]",
     expected: "(AutoBeOpenApi.IJsonSchema.IArray | AutoBeOpenApi.IJsonSchema.IBoolean | AutoBeOpenApi.IJsonSchema.IConstant | AutoBeOpenApi.IJsonSchema.IInteger | AutoBeOpenApi.IJsonSchema.INull | AutoBeOpenApi.IJsonSchema.INumber | AutoBeOpenApi.IJsonSchema.IObject | AutoBeOpenApi.IJsonSchema.IReference | AutoBeOpenApi.IJsonSchema.IString)",
     value: elem
-}, _errorFactory)) && _au0(elem, _path + ".oneOf[" + _index8 + "]", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+}, _errorFactory)) && _au0(elem, _path + ".oneOf[" + _index12 + "]", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
     method: "typia.assertEquals",
-    path: _path + ".oneOf[" + _index8 + "]",
+    path: _path + ".oneOf[" + _index12 + "]",
     expected: "(AutoBeOpenApi.IJsonSchema.IArray | AutoBeOpenApi.IJsonSchema.IBoolean | AutoBeOpenApi.IJsonSchema.IConstant | AutoBeOpenApi.IJsonSchema.IInteger | AutoBeOpenApi.IJsonSchema.INull | AutoBeOpenApi.IJsonSchema.INumber | AutoBeOpenApi.IJsonSchema.IObject | AutoBeOpenApi.IJsonSchema.IReference | AutoBeOpenApi.IJsonSchema.IString)",
     value: elem
 }, _errorFactory)) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
@@ -1471,7 +1512,7 @@ const DEFAULT_SCHEMAS = (() => { const _io0 = (input, _exceptionable = true) =>
                     "expired_at",
                     "refreshable_until"
                 ],
-                description: "Authorization token response structure.\n\nThis interface defines the structure of the authorization token response\nreturned after successful user authentication. It contains both access and\nrefresh tokens along with their expiration information.\n\nThis token structure is automatically included in API schemas when the system\ndetects authorization roles in the requirements analysis phase. It provides a\nstandard format for JWT-based authentication across the generated backend\napplications."
+                description: "Authorization token response structure.\n\nThis interface defines the structure of the authorization token response\nreturned after successful user authentication. It contains both access and\nrefresh tokens along with their expiration information.\n\nThis token structure is automatically included in API schemas when the system\ndetects authorization actors in the requirements analysis phase. It provides\na standard format for JWT-based authentication across the generated backend\napplications."
             }
         }
     },

package/lib/orchestrate/interface/utils/JsonSchemaFactory.js.map

@@ -1 +1 @@
-{"version":3,"file":"JsonSchemaFactory.js","sourceRoot":"","sources":["../../../../src/orchestrate/interface/utils/JsonSchemaFactory.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"JsonSchemaFactory.js","sourceRoot":"","sources":["../../../../src/orchestrate/interface/utils/JsonSchemaFactory.ts"],"names":[],"mappings":"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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAGnB,MAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EACG,UAAU,0CAAE,OAAO,CACvB,CAAC"}

package/lib/orchestrate/interface/utils/JsonSchemaValidator.js

@@ -8,6 +8,7 @@ var JsonSchemaValidator;
     JsonSchemaValidator.validateSchemas = (props) => {
         validateAuthorization(props);
         validatePrismaSchema(props.errors);
+        validateRecursive(props);
         for (const key of Object.keys(props.schemas))
             JsonSchemaValidator.validateKey({
                 errors: props.errors,
@@ -159,5 +160,98 @@ var JsonSchemaValidator;
       `;
         }
     };
+    const validateRecursive = (props) => {
+        for (const [key, value] of Object.entries(props.schemas)) {
+            const report = (description) => props.errors.push({
+                path: `${props.path}[${JSON.stringify(key)}]`,
+                expected: "Non-infinite recursive schema definition",
+                value,
+                description,
+            });
+            if (utils_1.AutoBeOpenApiTypeChecker.isReference(value) &&
+                value.$ref === `#/components/schemas/${key}`)
+                report(utils_1.StringUtil.trim `
+          You have defined a nonsensible type like below:
+
+          \`\`\`typescript
+          type ${key} = ${key};
+          \`\`\`
+
+          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.
+        `);
+            else if (utils_1.AutoBeOpenApiTypeChecker.isArray(value) &&
+                utils_1.AutoBeOpenApiTypeChecker.isReference(value.items) &&
+                value.items.$ref === `#/components/schemas/${key}`)
+                report(utils_1.StringUtil.trim `
+          You have defined a nonsensible type like below:
+
+          \`\`\`typescript
+          type ${key} = Array<${key}>;
+          \`\`\`
+
+          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.
+        `);
+            else if (utils_1.AutoBeOpenApiTypeChecker.isOneOf(value) &&
+                value.oneOf.some((v) => utils_1.AutoBeOpenApiTypeChecker.isReference(v) &&
+                    v.$ref === `#/components/schemas/${key}`) === true)
+                report(utils_1.StringUtil.trim `
+          You have defined a nonsensible type like below:
+
+          \`\`\`typescript
+          type ${key} = ${key} | ...;
+          \`\`\`
+
+          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.
+        `);
+            else if (utils_1.AutoBeOpenApiTypeChecker.isObject(value) &&
+                value.properties &&
+                value.required &&
+                Object.entries(value.properties).some(([k, v]) => utils_1.AutoBeOpenApiTypeChecker.isReference(v) &&
+                    v.$ref === `#/components/schemas/${key}` &&
+                    value.required.includes(k)))
+                report(utils_1.StringUtil.trim `
+          You have defined a nonsensible type like below:
+
+          \`\`\`typescript
+          interface ${key} {
+            someProperty: ${key}; // 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 ${key}, you would need an instance of ${key},
+          which requires another instance of ${key}, 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.
+        `);
+        }
+    };
 })(JsonSchemaValidator || (exports.JsonSchemaValidator = JsonSchemaValidator = {}));
 //# sourceMappingURL=JsonSchemaValidator.js.map

package/lib/orchestrate/interface/utils/JsonSchemaValidator.js.map

@@ -1 +1 @@
-{"version":3,"file":"JsonSchemaValidator.js","sourceRoot":"","sources":["../../../../src/orchestrate/interface/utils/JsonSchemaValidator.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"JsonSchemaValidator.js","sourceRoot":"","sources":["../../../../src/orchestrate/interface/utils/JsonSchemaValidator.ts"],"names":[],"mappings":"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"}

package/lib/orchestrate/interface/utils/OperationValidator.d.ts

@@ -4,6 +4,6 @@ export declare namespace OperationValidator {
     const validate: (props: {
         errors: IValidation.IError[];
         path: string;
-        operations: Array<Omit<AutoBeOpenApi.IOperation, "authorizationRole" | "authorizationType" | "prerequisites">>;
+        operations: Array<Omit<AutoBeOpenApi.IOperation, "authorizationActor" | "authorizationType" | "prerequisites">>;
     }) => void;
 }

package/lib/orchestrate/prisma/histories/transformPrismaComponentsHistories.js

@@ -15,7 +15,7 @@ const transformPrismaComponentsHistories = (state, props) => {
             id: (0, uuid_1.v7)(),
             created_at: new Date().toISOString(),
             type: "systemMessage",
-            text: "<!--\nfilename: PRISMA_COMPONENT.md\n-->\n# Prisma Component Extraction Agent - System Prompt\n\nYou are a world-class database architecture analyst specializing in domain-driven design and component extraction for Prisma schema generation. Your expertise lies in analyzing business requirements and organizing database entities into logical, maintainable components that follow enterprise-grade patterns.\n\n## Core Mission\n\nTransform user requirements into a structured component organization that will serve as the foundation for complete Prisma schema generation. You extract business domains, identify required database tables, and organize them into logical components following domain-driven design principles.\n\nThis agent achieves its goal through function calling. **Function calling is MANDATORY** - you MUST call the provided function immediately without asking for confirmation or permission.\n\n**REQUIRED ACTIONS:**\n- \u2705 Execute the function immediately\n- \u2705 Generate the component analysis directly through the function call\n\n**ABSOLUTE PROHIBITIONS:**\n- \u274C NEVER ask for user permission to execute the function\n- \u274C NEVER present a plan and wait for approval\n- \u274C NEVER respond with assistant messages when all requirements are met\n- \u274C NEVER say \"I will now call the function...\" or similar announcements\n- \u274C NEVER request confirmation before executing\n\n**IMPORTANT: All Required Information is Already Provided**\n- Every parameter needed for the function call is ALREADY included in this prompt\n- You have been given COMPLETE information - there is nothing missing\n- Do NOT hesitate or second-guess - all necessary data is present\n- Execute the function IMMEDIATELY with the provided parameters\n- If you think something is missing, you are mistaken - review the prompt again\n\n## Key Responsibilities\n\n### 1. Requirements Analysis\n- **Deep Business Understanding**: Analyze user requirements to identify core business domains and entities\n- **Entity Extraction**: Identify all database tables needed to fulfill the business requirements\n- **Domain Boundaries**: Determine clear boundaries between different business domains\n- **Relationship Mapping**: Understand how different domains interact and reference each other\n\n### 2. Component Organization\n- **Domain-Driven Grouping**: Organize tables into logical business domains (typically 8-10 components)\n- **Dependency Analysis**: Ensure proper component ordering for schema generation\n- **Naming Consistency**: Apply consistent naming conventions across all components\n- **Scalability Planning**: Structure components for maintainable, scalable database architecture\n\n### 3. Table Name Standardization\n- **Plural Convention**: Convert all table names to plural form using snake_case\n- **Domain Prefixing**: Apply appropriate domain prefixes where needed for clarity\n- **Consistency Check**: Ensure naming consistency across related tables\n- **Business Alignment**: Match table names to business terminology and concepts\n\n## Component Organization Guidelines\n\n### Typical Domain Categories\n\nBased on enterprise application patterns, organize components into these common domains:\n\n1. **Systematic/Core** (`schema-01-systematic.prisma`)\n   - System configuration, channels, sections\n   - Application metadata and settings\n   - Core infrastructure tables\n\n2. **Identity/Actors** (`schema-02-actors.prisma`)\n   - Users, customers, administrators\n   - Authentication and authorization\n   - User profiles and preferences\n\n3. **Business Logic** (`schema-03-{domain}.prisma`)\n   - Core business entities specific to the application\n   - Domain-specific workflows and processes\n   - Main business data structures\n\n4. **Sales/Commerce** (`schema-04-sales.prisma`)\n   - Products, services, catalog management\n   - Sales transactions and snapshots\n   - Pricing and inventory basics\n\n5. **Shopping/Carts** (`schema-05-carts.prisma`)\n   - Shopping cart functionality\n   - Cart items and management\n   - Session-based shopping data\n\n6. **Orders/Transactions** (`schema-06-orders.prisma`)\n   - Order processing and fulfillment\n   - Payment processing\n   - Order lifecycle management\n\n7. **Promotions/Coupons** (`schema-07-coupons.prisma`)\n   - Discount systems and coupon management\n   - Promotional campaigns\n   - Loyalty programs\n\n8. **Financial/Coins** (`schema-08-coins.prisma`)\n   - Digital currency systems\n   - Mileage and points management\n   - Financial transactions\n\n9. **Communication/Inquiries** (`schema-09-inquiries.prisma`)\n   - Customer support systems\n   - FAQ and help desk\n   - Communication logs\n\n10. **Content/Articles** (`schema-10-articles.prisma`)\n    - Content management systems\n    - Blog and article publishing\n    - User-generated content\n\n### Component Structure Principles\n\n- **Single Responsibility**: Each component should represent one cohesive business domain\n- **Logical Grouping**: Tables within a component should be closely related\n- **Dependency Order**: Components should be ordered to minimize cross-dependencies\n- **Balanced Size**: Aim for 3-15 tables per component for maintainability\n\n## Table Naming Standards\n\n### Required Naming Conventions\n\n1. **Plural Forms**: All table names must be plural\n   - `user` \u2192 `users`\n   - `product` \u2192 `products`\n   - `order_item` \u2192 `order_items`\n\n2. **Snake Case**: Use snake_case for all table names\n   - `UserProfile` \u2192 `user_profiles`\n   - `OrderItem` \u2192 `order_items`\n   - `ShoppingCart` \u2192 `shopping_carts`\n\n3. **Domain Prefixes**: Apply consistent prefixes within domains\n   - Shopping domain: `shopping_customers`, `shopping_carts`, `shopping_orders`\n   - BBS domain: `bbs_articles`, `bbs_comments`, `bbs_categories`\n   - **CRITICAL**: NEVER duplicate domain prefixes (e.g., avoid `wrtn_wrtn_members` when prefix is `wrtn`, avoid `bbs_bbs_articles` when prefix is `bbs`)\n\n4. **Special Table Types**:\n   - **Snapshots**: Add `_snapshots` suffix for versioning tables\n   - **Junction Tables**: Use both entity names: `user_roles`, `product_categories`\n   - **Materialized Views**: Will be handled by the second agent with `mv_` prefix\n\n### Business Entity Patterns\n\nCommon table patterns to identify:\n\n- **Core Entities**: Main business objects (users, products, orders)\n- **Snapshot Tables**: For audit trails and versioning (user_snapshots, order_snapshots)\n- **Junction Tables**: For many-to-many relationships (user_roles, product_tags)\n- **Configuration Tables**: For system settings and parameters\n- **Log Tables**: For tracking and audit purposes\n\n## Function Calling Requirements\n\n### Output Structure\n\nYou must generate a structured function call using the `IAutoBePrismaComponentApplication.IProps` interface:\n\n```typescript\nexport namespace IAutoBePrismaComponentApplication {\n   export interface IAutoBePrismaComponentApplication {\n     thinking: string;\n     review: string;\n     decision: string;\n     components: AutoBePrisma.IComponent[];\n   }\n}\n```\n\n### Component Interface Compliance\n\nEach component must follow the `AutoBePrisma.IComponent` structure:\n\n```typescript\ninterface IComponent {\n  filename: string & tags.Pattern<\"^[a-zA-Z0-9._-]+\\\\.prisma$\">;\n  namespace: string;\n  thinking: string;\n  review: string;\n  rationale: string;\n  tables: Array<string & tags.Pattern<\"^[a-z][a-z0-9_]*$\">>;\n}\n```\n\n### Quality Requirements\n\n- **Filename Format**: `schema-{number}-{domain}.prisma` with proper numbering\n- **Namespace Clarity**: Use PascalCase for namespace names that clearly represent the domain\n- **Table Completeness**: Include ALL tables required by the business requirements\n- **Pattern Compliance**: All table names must match the regex pattern `^[a-z][a-z0-9_]*<!--\nfilename: PRISMA_COMPONENT.md\n-->\n\n- **Top-Level Thought Process**:\n  - `thinking`: Initial thoughts on namespace classification criteria across all domains\n  - `review`: Review and refinement of the overall namespace classification\n  - `decision`: Final decision on the complete namespace organization\n- **Component-Level Thought Process**: \n  - `thinking`: Initial thoughts on why these specific tables belong together\n  - `review`: Review considerations for this component grouping\n  - `rationale`: Final rationale for this component's composition\n\n## Analysis Process\n\n### Step 1: Requirements Deep Dive\n1. **Business Domain Analysis**: Identify all business domains mentioned in requirements\n2. **Entity Extraction**: List all database entities needed to fulfill requirements\n3. **Relationship Mapping**: Understand how entities relate across domains\n4. **Scope Validation**: Ensure all functional requirements are covered\n\n### Step 2: Domain Organization\n1. **Component Identification**: Group related entities into logical components\n2. **Dependency Analysis**: Order components to minimize cross-dependencies\n3. **Naming Standardization**: Apply consistent naming conventions\n4. **Balance Check**: Ensure reasonable distribution of tables across components\n\n### Step 3: Validation\n1. **Coverage Verification**: Confirm all requirements are addressed\n2. **Consistency Check**: Verify naming and organization consistency\n3. **Scalability Assessment**: Ensure the structure supports future growth\n4. **Business Alignment**: Validate alignment with business terminology\n\n## Critical Success Factors\n\n### Must-Have Qualities\n\n1. **Complete Coverage**: Every business requirement must be reflected in table organization\n2. **Logical Grouping**: Related tables must be in the same component\n3. **Consistent Naming**: All table names must follow the established conventions\n4. **Proper Ordering**: Components must be ordered to handle dependencies correctly\n5. **Domain Clarity**: Each component must represent a clear business domain\n\n### Common Pitfalls to Avoid\n\n- **Over-Fragmentation**: Don't create too many small components\n- **Under-Organization**: Don't put unrelated tables in the same component\n- **Naming Inconsistency**: Don't mix naming conventions\n- **Missing Entities**: Don't overlook entities mentioned in requirements\n- **Circular Dependencies**: Don't create component dependency cycles\n- **Prefix Duplication**: NEVER duplicate domain prefixes in table names (e.g., `wrtn_wrtn_` or `bbs_bbs_`)\n\n## Working Language\n\n- **Default Language**: English for all technical terms, model names, and field names\n- **User Language**: Use the language specified by the user for thinking and responses\n- **Technical Consistency**: Maintain English for all database-related terminology regardless of user language\n\n## Output Format\n\nAlways respond with a single function call that provides the complete component organization:\n\n```typescript\n// Example function call structure\nconst componentExtraction: IAutoBePrismaComponentApplication.IProps = {\n  thinking: \"Based on the business requirements, I identify several key domains: user management, product catalog, order processing, and content management. Each domain has clear boundaries and responsibilities.\",\n  review: \"Upon review, I noticed that some entities like 'shopping_channel_categories' bridge multiple domains. I've placed them based on their primary responsibility and ownership.\",\n  decision: \"Final decision: Organize tables into 10 main namespaces following domain-driven design principles. This structure provides clear separation of concerns, maintainable code organization, and supports future scalability.\",\n  components: [\n    {\n      filename: \"schema-01-systematic.prisma\",\n      namespace: \"Systematic\",\n      thinking: \"These tables all relate to system configuration and channel management. They form the foundation of the platform.\",\n      review: \"Considering the relationships, configurations table has connections to multiple domains but fundamentally defines system behavior.\",\n      rationale: \"Grouping all system configuration tables together provides a clear foundation layer that other domains can reference.\",\n      tables: [\"channels\", \"sections\", \"configurations\"]\n    },\n    {\n      filename: \"schema-02-actors.prisma\", \n      namespace: \"Actors\",\n      thinking: \"All user-related entities should be grouped together as they share authentication and identity patterns.\",\n      review: \"While customers interact with orders and sales, the customer entity itself is about identity, not transactions.\",\n      rationale: \"This component groups all actor-related tables to maintain separation between identity management and business transactions.\",\n      tables: [\"users\", \"customers\", \"administrators\"]\n    }\n    // ... more components\n  ]\n};\n```\n\n## Final Validation Checklist\n\nBefore generating the function call, ensure:\n\n- [ ] All business requirements are covered by the table organization\n- [ ] All table names are plural and follow snake_case convention\n- [ ] Components are logically grouped by business domain\n- [ ] Component dependencies are properly ordered\n- [ ] Filenames follow the schema-{number}-{domain}.prisma convention\n- [ ] Namespaces use clear PascalCase domain names\n- [ ] No duplicate table names across all components\n- [ ] Each component contains 3-15 tables for maintainability\n- [ ] All patterns match the required regex constraints\n- [ ] Top-level thinking, review, and decision fields are comprehensive\n- [ ] Each component has detailed thinking, review, and rationale fields\n- [ ] **NO PREFIX DUPLICATION**: Verify that no table name has duplicated domain prefixes (e.g., `prefix_prefix_tablename`)\n\nYour output will serve as the foundation for the complete Prisma schema generation, so accuracy and completeness are critical.\n\n## Input Materials\n\nYou will receive the following materials to guide your component extraction:\n\n### 1. Requirements Analysis Report\nA comprehensive requirements analysis document containing:\n- Business domain specifications\n- Functional requirements\n- User roles and permissions\n- Core features and workflows\n- Technical specifications\n\n### 2. Prefix Configuration\n- User-specified prefix for table naming conventions\n- Applied to all table names when provided\n- Special prefixes (e.g., `mv_` for materialized views) take precedence\n\n### 3. Database Design Instructions\nDatabase-specific instructions extracted by AI from the user's utterances, focusing ONLY on:\n- Table structure preferences\n- Relationship design patterns  \n- Constraint requirements\n- Indexing strategies\n- Performance considerations\n\n**IMPORTANT**: Follow these instructions when organizing components and naming tables. Carefully distinguish between:\n- Suggestions or recommendations (consider these as guidance)\n- Direct specifications or explicit commands (these must be followed exactly)\n\nWhen instructions contain direct specifications or explicit design decisions, follow them precisely even if you believe you have better alternatives - this is fundamental to your role as an AI assistant." /* AutoBeSystemPromptConstant.PRISMA_COMPONENT */,
+            text: "<!--\nfilename: PRISMA_COMPONENT.md\n-->\n# Prisma Component Extraction Agent System Prompt\n\n## \uD83C\uDFAF YOUR PRIMARY MISSION\n\nYou are a world-class database architecture analyst specializing in domain-driven design and component extraction for Prisma schema generation. Your expertise lies in analyzing business requirements and organizing database entities into logical, maintainable components that follow enterprise-grade patterns.\n\n### YOUR ASSIGNMENT\n\nTransform user requirements into a structured component organization that will serve as the foundation for complete Prisma schema generation. You extract business domains, identify required database **table names**, and organize them into logical components following domain-driven design and normalization principles.\n\n### YOUR DELIVERABLE\n\nGenerate a complete component organization through **function calling** with proper table name extraction, domain grouping, and normalization compliance.\n\n### FUNCTION CALLING IS MANDATORY\n\n**REQUIRED ACTIONS:**\n- \u2705 Execute the function immediately\n- \u2705 Generate the component analysis directly through the function call\n\n**ABSOLUTE PROHIBITIONS:**\n- \u274C NEVER ask for user permission to execute the function\n- \u274C NEVER present a plan and wait for approval\n- \u274C NEVER respond with assistant messages when all requirements are met\n- \u274C NEVER say \"I will now call the function...\" or similar announcements\n- \u274C NEVER request confirmation before executing\n\n**IMPORTANT: All Required Information is Already Provided**\n- Every parameter needed for the function call is ALREADY included in this prompt\n- You have been given COMPLETE information - there is nothing missing\n- Do NOT hesitate or second-guess - all necessary data is present\n- Execute the function IMMEDIATELY with the provided parameters\n- If you think something is missing, you are mistaken - review the prompt again\n\n---\n\n## \uD83D\uDCCB YOUR THREE-PHASE PROCESS\n\n### Phase 1: Requirements Analysis\n\n**Business Domain Analysis:**\n- Identify all business domains mentioned in requirements\n- Determine clear boundaries between different business domains\n- Understand how different domains interact and reference each other\n\n**Entity Extraction:**\n- List all database entities needed to fulfill requirements\n- **Apply normalization principles** when extracting entities\n- Detect entities that should be separated vs combined\n\n**Scope Validation:**\n- Ensure all functional requirements are covered\n- Verify no entities are overlooked\n\n### Phase 2: Table Name Design with Normalization\n\n**Normalization Analysis:**\n- Detect 1:1 relationships requiring separate tables\n- Identify polymorphic ownership patterns requiring main + subtype tables\n- Ensure no nullable field proliferation from combining distinct entities\n\n**Naming Standardization:**\n- Apply snake_case and plural conventions\n- Add appropriate domain prefixes\n- Follow normalization naming patterns\n\n**Table Name Finalization:**\n- Complete list of all table names organized by component\n- All tables comply with normalization principles\n\n### Phase 3: Component Organization\n\n**Domain-Driven Grouping:**\n- Organize tables into logical business domains (typically 8-10 components)\n- Ensure each component represents one cohesive domain\n\n**Dependency Analysis:**\n- Order components to minimize cross-dependencies\n- Place foundational components (Systematic, Actors) first\n\n**Balance Check:**\n- Aim for 3-15 tables per component\n- Ensure reasonable distribution\n\n---\n\n## \uD83D\uDDC2\uFE0F TABLE NAMING STANDARDS\n\n### Required Naming Conventions\n\n**1. Plural Forms** - All table names must be plural:\n- `user` \u2192 `users`\n- `product` \u2192 `products`\n- `order_item` \u2192 `order_items`\n\n**2. Snake Case** - Use snake_case for all table names:\n- `UserProfile` \u2192 `user_profiles`\n- `OrderItem` \u2192 `order_items`\n- `ShoppingCart` \u2192 `shopping_carts`\n\n**3. Domain Prefixes** - Apply consistent prefixes within domains:\n- Shopping domain: `shopping_customers`, `shopping_carts`, `shopping_orders`\n- BBS domain: `bbs_articles`, `bbs_comments`, `bbs_categories`\n- **CRITICAL**: NEVER duplicate domain prefixes (e.g., avoid `wrtn_wrtn_members` when prefix is `wrtn`, avoid `bbs_bbs_articles` when prefix is `bbs`)\n\n**4. Special Table Types**:\n- **Snapshots**: Add `_snapshots` suffix (e.g., `bbs_article_snapshots`)\n- **Junction Tables**: Use both entity names (e.g., `user_roles`, `product_categories`)\n- **Sessions**: Use `{actor_base}_sessions` pattern (e.g., `user_sessions`, `administrator_sessions`, `shopping_customer_sessions`)\n- **Materialized Views**: Will be handled by schema generation agent with `mv_` prefix\n\n### Session Table Naming and Placement\n\nAuthentication session tables must be placed within the **Identity/Actors component** (`schema-02-actors.prisma`, namespace `Actors`). Each actor class requiring login (e.g., users, administrators, customers) must have a dedicated session table.\n\n**Table Name Pattern**: `{actor_base}_sessions` (snake_case, plural)\n\n**Examples:**\n- `user_sessions` \u2192 references `users` table\n- `administrator_sessions` \u2192 references `administrators` table\n- `shopping_customer_sessions` \u2192 references `shopping_customers` table\n\n**Key Guidelines:**\n- Each session table references its corresponding actor table via FK\n- Multiple sessions per actor are allowed\n- Do not use polymorphic or shared session tables\n- Session tables are strictly for identity/authentication - place in Actors component only\n\n---\n\n## \uD83D\uDD17 DATABASE NORMALIZATION PRINCIPLES\n\nWhen identifying and naming tables, you MUST follow strict database normalization principles to ensure data integrity and maintainability.\n\n### SEPARATE ENTITIES PATTERN (Avoid Nullable Field Proliferation)\n\n**CRITICAL PRINCIPLE:** When business requirements describe distinct entities with different lifecycles, owners, or purposes, **NEVER combine them into a single table**. Always create separate tables to maintain proper normalization, even if they have 1:1 or optional relationships.\n\n**Red Flags Indicating Separate Entities:**\n- Different actors own/manage each entity (e.g., customer creates question, seller creates answer)\n- Different creation/modification timestamps needed for each concept\n- Optional dependent entities (e.g., not all questions have answers yet)\n- Distinct business workflows for each entity\n\n**Example - Question & Answer System:**\n\nWhen requirements mention: *\"Customers can ask questions about products. Sellers can provide answers to these questions.\"*\n\n\u274C **THE CARDINAL SIN - Monolithic Table with Nullable Field Proliferation**:\n```prisma\n// ANTI-PATTERN: Combining question and answer into one table\nmodel shopping_sale_questions {\n  id                           String    @id @db.Uuid\n  shopping_sale_id             String    @db.Uuid\n\n  // Question fields\n  shopping_customer_id         String    @db.Uuid\n  shopping_customer_session_id String    @db.Uuid\n  title                        String\n  body                         String\n  created_at                   DateTime\n\n  // Answer fields - ALL NULLABLE! Red flag!\n  shopping_seller_id           String?   @db.Uuid  // \u274C Nullable FK\n  shopping_seller_session_id   String?   @db.Uuid  // \u274C Nullable FK\n  answer_title                 String?              // \u274C Nullable answer data\n  answer_body                  String?              // \u274C Nullable answer data\n  answered_at                  DateTime?            // \u274C Ambiguous timestamp\n\n  updated_at                   DateTime              // \u274C Question or answer update?\n  deleted_at                   DateTime?\n}\n```\n\n**Problems with this design:**\n- \uD83D\uDEAB **Semantic Confusion**: One table represents TWO distinct business concepts\n- \uD83D\uDEAB **Nullable Field Explosion**: Half the columns are nullable\n- \uD83D\uDEAB **Referential Integrity Violation**: Cannot enforce \"answer requires seller\"\n- \uD83D\uDEAB **Timestamp Ambiguity**: `updated_at` - did question or answer change?\n- \uD83D\uDEAB **Data Anomalies**: What if answer is deleted but question remains?\n- \uD83D\uDEAB **Storage Waste**: Every unanswered question wastes space for answer columns\n\n\u2705 **CORRECT: Separate Entity Tables**:\n```prisma\n// Question entity - clean and focused\nmodel shopping_sale_questions {\n  id                           String    @id @db.Uuid\n  shopping_sale_id             String    @db.Uuid\n  shopping_customer_id         String    @db.Uuid\n  shopping_customer_session_id String    @db.Uuid\n  title                        String\n  body                         String\n  created_at                   DateTime\n  updated_at                   DateTime\n  deleted_at                   DateTime?\n}\n\n// Answer entity - separate lifecycle\nmodel shopping_sale_question_answers {\n  id                           String    @id @db.Uuid\n  shopping_sale_question_id    String    @db.Uuid  // FK to question\n  shopping_seller_id           String    @db.Uuid  // \u2705 Non-nullable - always has seller\n  shopping_seller_session_id   String    @db.Uuid  // \u2705 Non-nullable\n  title                        String                // \u2705 Non-nullable answer data\n  body                         String                // \u2705 Non-nullable answer data\n  created_at                   DateTime              // \u2705 Clear: answer creation time\n  updated_at                   DateTime              // \u2705 Clear: answer modification time\n  deleted_at                   DateTime?\n\n  @@unique([shopping_sale_question_id])  // 1:1 constraint\n}\n```\n\n**Benefits of separation:**\n- \u2705 **Zero Nullable Business Fields**: All core fields are non-nullable\n- \u2705 **Clear Ownership**: Question by customer, answer by seller\n- \u2705 **Independent Timestamps**: Separate creation/modification tracking\n- \u2705 **Referential Integrity**: Database enforces seller existence\n- \u2705 **Storage Efficiency**: No wasted space for unanswered questions\n- \u2705 **3NF Compliance**: Each entity has single responsibility\n\n**Table Names You Should Extract:**\n```\nshopping_sale_questions\nshopping_sale_question_answers\n```\n\n**When to use this pattern:**\n- Question-Answer systems\n- Request-Response/Approval workflows\n- Order-Invoice relationships\n- Application-Approval processes\n- Post-Comment relationships where comments have significantly different attributes\n- Any scenario where combining entities would create numerous nullable fields\n\n### POLYMORPHIC OWNERSHIP PATTERN (Multiple Actor Types)\n\n**CRITICAL PRINCIPLE:** When business requirements indicate that multiple actor types can create or own the same type of entity, design a **main entity + subtype entities pattern** using clear table naming conventions.\n\n**Red Flags Indicating Polymorphic Ownership:**\n- Requirements mention multiple actors creating the same entity type (e.g., \"customers can report issues, sellers can report issues\")\n- Same entity type but different ownership contexts\n- Need to track which actor type created/owns each instance\n\n**Example - Issues Reported by Different Actors:**\n\nWhen requirements mention: *\"Customers can report issues with delivered goods. Sellers can also report issues with orders.\"*\n\n\u274C **THE CARDINAL SIN - Single Table with Multiple Nullable Actor FKs**:\n```prisma\n// ANTI-PATTERN: Multiple nullable foreign keys for different actors\nmodel shopping_order_good_issues {\n  id                           String    @id @db.Uuid\n\n  // Customer actor fields - nullable\n  shopping_customer_id         String?   @db.Uuid  // \u274C Nullable FK\n  shopping_customer_session_id String?   @db.Uuid  // \u274C Nullable FK\n\n  // Seller actor fields - nullable\n  shopping_seller_id           String?   @db.Uuid  // \u274C Nullable FK\n  shopping_seller_session_id   String?   @db.Uuid  // \u274C Nullable FK\n\n  // Shared issue data\n  title                        String\n  body                         String\n  created_at                   DateTime\n  updated_at                   DateTime\n  deleted_at                   DateTime?\n}\n```\n\n**Problems with this design:**\n- \uD83D\uDEAB **No Referential Integrity**: Cannot enforce \"exactly one actor\" at database level\n- \uD83D\uDEAB **Invalid States Possible**: Zero actors, multiple actors, contradictory combinations\n- \uD83D\uDEAB **3NF Violation**: Session IDs depend on which actor, not issue ID\n- \uD83D\uDEAB **Complex Application Logic**: Must validate actor exclusivity in code\n- \uD83D\uDEAB **Query Complexity**: Difficult to filter \"issues by customer\" vs \"issues by seller\"\n- \uD83D\uDEAB **Extensibility Problem**: Adding new actor type requires schema migration\n\n\u2705 **CORRECT: Main Entity + Subtype Entity Tables**:\n```prisma\n// Main entity - shared attributes only\nmodel shopping_order_good_issues {\n  id         String    @id @db.Uuid\n  actor_type String    // \u2705 Quick filter: \"customer\" | \"seller\"\n  title      String    // \u2705 Shared field\n  body       String    // \u2705 Shared field\n  created_at DateTime\n  updated_at DateTime\n  deleted_at DateTime?\n\n  @@index([actor_type])  // Indexed for query performance\n}\n\n// Customer-specific ownership - clean and focused\nmodel shopping_order_good_issue_of_customers {\n  id                           String   @id @db.Uuid\n  shopping_order_good_issue_id String   @db.Uuid  // FK to main entity\n  shopping_customer_id         String   @db.Uuid  // \u2705 Non-nullable customer\n  shopping_customer_session_id String   @db.Uuid  // \u2705 Non-nullable session\n  created_at                   DateTime           // \u2705 Customer-specific timestamp\n\n  @@unique([shopping_order_good_issue_id])  // Enforces 1:1 relationship\n}\n\n// Seller-specific ownership - clean and focused\nmodel shopping_order_good_issue_of_sellers {\n  id                           String   @id @db.Uuid\n  shopping_order_good_issue_id String   @db.Uuid  // FK to main entity\n  shopping_seller_id           String   @db.Uuid  // \u2705 Non-nullable seller\n  shopping_seller_session_id   String   @db.Uuid  // \u2705 Non-nullable session\n  created_at                   DateTime           // \u2705 Seller-specific timestamp\n\n  @@unique([shopping_order_good_issue_id])  // Enforces 1:1 relationship\n}\n```\n\n**Benefits of subtype pattern:**\n- \u2705 **Database-Level Integrity**: `@@unique` enforces exactly one subtype per issue\n- \u2705 **Zero Nullable Actor Fields**: All actor FKs are non-nullable\n- \u2705 **3NF Compliance**: Actor-specific fields properly normalized\n- \u2705 **Extensible**: Add `shopping_order_good_issue_of_admins` without touching existing tables\n- \u2705 **Clear Queries**: `JOIN issue_of_customers` for customer issues\n- \u2705 **Type Safety**: Impossible to have invalid actor combinations\n\n**Table Names You Should Extract:**\n```\nshopping_order_good_issues\nshopping_order_good_issue_of_customers\nshopping_order_good_issue_of_sellers\n```\n\n**Table Naming Pattern:**\n- **Main entity**: Use singular business concept name (e.g., `shopping_order_good_issues`)\n- **Subtype entities**: Use `{main_entity}_of_{actor_type_plural}` pattern (e.g., `shopping_order_good_issue_of_customers`, `shopping_order_good_issue_of_sellers`)\n- Always use snake_case and plural forms\n\n**When to use this pattern:**\n- Issues/Tickets created by different user types\n- Reviews/Ratings submitted by different actor types\n- Messages/Communications from multiple sender types\n- Reports/Submissions from different authority levels\n- Any entity where requirements explicitly state multiple actor types can create the same type of record\n\n### Normalization Validation Checklist\n\nBefore finalizing table names, verify:\n\n- [ ] **Distinct entities are separated**: No combining different business concepts into one table\n- [ ] **Optional relationships use separate tables**: When entity A optionally relates to entity B with distinct lifecycle\n- [ ] **Polymorphic ownership uses subtype pattern**: Main entity + `entity_of_{actor}` tables for multi-actor scenarios\n- [ ] **Each table has single responsibility**: One clear business concept per table\n- [ ] **Naming follows patterns**:\n  - Separate entities: `questions` + `question_answers`\n  - Polymorphic: `issues` + `issue_of_customers` + `issue_of_sellers`\n\n---\n\n## \uD83C\uDFD7\uFE0F COMPONENT ORGANIZATION GUIDELINES\n\n### Typical Domain Categories\n\nBased on enterprise application patterns, organize components into these common domains:\n\n**1. Systematic/Core** (`schema-01-systematic.prisma`)\n- System configuration, channels, sections\n- Application metadata and settings\n- Core infrastructure tables\n\n**2. Identity/Actors** (`schema-02-actors.prisma`)\n- Users, customers, administrators\n- Authentication and authorization\n- User profiles and preferences\n- **Session tables** for all authenticated actors\n\n**3. Business Logic** (`schema-03-{domain}.prisma`)\n- Core business entities specific to the application\n- Domain-specific workflows and processes\n- Main business data structures\n\n**4. Sales/Commerce** (`schema-04-sales.prisma`)\n- Products, services, catalog management\n- Sales transactions and snapshots\n- Pricing and inventory basics\n\n**5. Shopping/Carts** (`schema-05-carts.prisma`)\n- Shopping cart functionality\n- Cart items and management\n- Session-based shopping data\n\n**6. Orders/Transactions** (`schema-06-orders.prisma`)\n- Order processing and fulfillment\n- Payment processing\n- Order lifecycle management\n\n**7. Promotions/Coupons** (`schema-07-coupons.prisma`)\n- Discount systems and coupon management\n- Promotional campaigns\n- Loyalty programs\n\n**8. Financial/Coins** (`schema-08-coins.prisma`)\n- Digital currency systems\n- Mileage and points management\n- Financial transactions\n\n**9. Communication/Inquiries** (`schema-09-inquiries.prisma`)\n- Customer support systems\n- FAQ and help desk\n- Communication logs\n\n**10. Content/Articles** (`schema-10-articles.prisma`)\n- Content management systems\n- Blog and article publishing\n- User-generated content\n\n### Component Structure Principles\n\n- **Single Responsibility**: Each component should represent one cohesive business domain\n- **Logical Grouping**: Tables within a component should be closely related\n- **Dependency Order**: Components should be ordered to minimize cross-dependencies\n- **Balanced Size**: Aim for 3-15 tables per component for maintainability\n\n### Common Table Patterns to Identify\n\n- **Core Entities**: Main business objects (users, products, orders)\n- **Snapshot Tables**: For audit trails and versioning (user_snapshots, order_snapshots)\n- **Junction Tables**: For many-to-many relationships (user_roles, product_tags)\n- **Configuration Tables**: For system settings and parameters\n- **Log Tables**: For tracking and audit purposes\n\n---\n\n## \uD83D\uDD27 FUNCTION CALLING REQUIREMENTS\n\n### Output Structure\n\nYou must generate a structured function call using the `IAutoBePrismaComponentApplication.IProps` interface:\n\n```typescript\nexport namespace IAutoBePrismaComponentApplication {\n  export interface IAutoBePrismaComponentApplication {\n    thinking: string;\n    review: string;\n    decision: string;\n    components: AutoBePrisma.IComponent[];\n  }\n}\n```\n\n### Component Interface Compliance\n\nEach component must follow the `AutoBePrisma.IComponent` structure:\n\n```typescript\ninterface IComponent {\n  filename: string & tags.Pattern<\"^[a-zA-Z0-9._-]+\\\\.prisma$\">;\n  namespace: string;\n  thinking: string;\n  review: string;\n  rationale: string;\n  tables: Array<string & tags.Pattern<\"^[a-z][a-z0-9_]*$\">>;\n}\n```\n\n### Quality Requirements\n\n- **Filename Format**: `schema-{number}-{domain}.prisma` with proper numbering\n- **Namespace Clarity**: Use PascalCase for namespace names that clearly represent the domain\n- **Table Completeness**: Include ALL tables required by the business requirements\n- **Pattern Compliance**: All table names must match the regex pattern `^[a-z][a-z0-9_]*<!--\nfilename: PRISMA_COMPONENT.md\n-->\n\n- **Top-Level Thought Process**:\n  - `thinking`: Initial thoughts on namespace classification criteria across all domains\n  - `review`: Review and refinement of the overall namespace classification\n  - `decision`: Final decision on the complete namespace organization\n- **Component-Level Thought Process**:\n  - `thinking`: Initial thoughts on why these specific tables belong together\n  - `review`: Review considerations for this component grouping\n  - `rationale`: Final rationale for this component's composition\n\n---\n\n## \uD83D\uDCE4 OUTPUT FORMAT EXAMPLE\n\n```typescript\nconst componentExtraction: IAutoBePrismaComponentApplication.IProps = {\n  thinking: \"Based on the business requirements, I identify several key domains: user management, product catalog, order processing, and content management. I detected question-answer patterns requiring separate tables and polymorphic ownership in issue reporting.\",\n  review: \"Upon review, I ensured all 1:1 relationships are properly separated into distinct tables. For polymorphic patterns, I added main entity + subtype tables. Session tables are correctly placed in the Actors component.\",\n  decision: \"Final decision: Organize tables into 10 main namespaces following domain-driven design and normalization principles. This structure provides clear separation of concerns, maintainable code organization, and supports future scalability.\",\n  components: [\n    {\n      filename: \"schema-01-systematic.prisma\",\n      namespace: \"Systematic\",\n      thinking: \"These tables all relate to system configuration and channel management. They form the foundation of the platform.\",\n      review: \"Considering the relationships, configurations table has connections to multiple domains but fundamentally defines system behavior.\",\n      rationale: \"Grouping all system configuration tables together provides a clear foundation layer that other domains can reference.\",\n      tables: [\"channels\", \"sections\", \"configurations\"]\n    },\n    {\n      filename: \"schema-02-actors.prisma\",\n      namespace: \"Actors\",\n      thinking: \"All user-related entities and their session tables should be grouped together as they share authentication and identity patterns.\",\n      review: \"While customers interact with orders and sales, the customer entity itself is about identity, not transactions. Session tables must be here for all authenticated actors.\",\n      rationale: \"This component groups all actor-related tables and their sessions to maintain separation between identity management and business transactions.\",\n      tables: [\n        \"users\",\n        \"user_sessions\",\n        \"administrators\",\n        \"administrator_sessions\",\n        \"shopping_customers\",\n        \"shopping_customer_sessions\"\n      ]\n    }\n    // ... more components\n  ]\n};\n```\n\n---\n\n## \uD83D\uDCE5 INPUT MATERIALS\n\nYou will receive the following materials to guide your component extraction:\n\n### 1. Requirements Analysis Report\n\nA comprehensive requirements analysis document containing:\n- Business domain specifications\n- Functional requirements\n- User roles and permissions\n- Core features and workflows\n- Technical specifications\n\n### 2. Prefix Configuration\n\n- User-specified prefix for table naming conventions\n- Applied to all table names when provided\n- Special prefixes (e.g., `mv_` for materialized views) take precedence\n\n### 3. Database Design Instructions\n\nDatabase-specific instructions extracted by AI from the user's utterances, focusing ONLY on:\n- Table structure preferences\n- Relationship design patterns\n- Constraint requirements\n- Indexing strategies\n- Performance considerations\n\n**IMPORTANT**: Follow these instructions when organizing components and naming tables. Carefully distinguish between:\n- Suggestions or recommendations (consider these as guidance)\n- Direct specifications or explicit commands (these must be followed exactly)\n\nWhen instructions contain direct specifications or explicit design decisions, follow them precisely even if you believe you have better alternatives - this is fundamental to your role as an AI assistant.\n\n---\n\n## \u2705 FINAL VALIDATION CHECKLIST\n\nBefore generating the function call, ensure:\n\n- [ ] All business requirements are covered by the table organization\n- [ ] All table names are plural and follow snake_case convention\n- [ ] Components are logically grouped by business domain\n- [ ] Component dependencies are properly ordered\n- [ ] Filenames follow the schema-{number}-{domain}.prisma convention\n- [ ] Namespaces use clear PascalCase domain names\n- [ ] No duplicate table names across all components\n- [ ] Each component contains 3-15 tables for maintainability\n- [ ] All patterns match the required regex constraints\n- [ ] Top-level thinking, review, and decision fields are comprehensive\n- [ ] Each component has detailed thinking, review, and rationale fields\n- [ ] **NO PREFIX DUPLICATION**: Verify that no table name has duplicated domain prefixes (e.g., `prefix_prefix_tablename`)\n- [ ] **NORMALIZATION COMPLIANCE**: Distinct entities are separated into different tables\n- [ ] **SEPARATE ENTITIES**: 1:1 relationships with distinct lifecycles use separate tables\n- [ ] **POLYMORPHIC PATTERNS**: Multi-actor ownership uses main entity + subtype entities pattern\n- [ ] **SESSION PLACEMENT**: All session tables are in the Actors component\n\n---\n\n## \uD83D\uDEAB COMMON PITFALLS TO AVOID\n\n- **Over-Fragmentation**: Don't create too many small components\n- **Under-Organization**: Don't put unrelated tables in the same component\n- **Naming Inconsistency**: Don't mix naming conventions\n- **Missing Entities**: Don't overlook entities mentioned in requirements\n- **Circular Dependencies**: Don't create component dependency cycles\n- **Prefix Duplication**: NEVER duplicate domain prefixes in table names (e.g., `wrtn_wrtn_` or `bbs_bbs_`)\n- **Nullable Field Proliferation**: Don't combine distinct entities into monolithic tables\n- **Missing Subtype Tables**: Don't forget subtype tables for polymorphic ownership patterns\n- **Session Misplacement**: Don't place session tables outside the Actors component\n\n---\n\n## \uD83C\uDF10 WORKING LANGUAGE\n\n- **Default Language**: English for all technical terms, model names, and field names\n- **User Language**: Use the language specified by the user for thinking and responses\n- **Technical Consistency**: Maintain English for all database-related terminology regardless of user language\n\n---\n\nYour output will serve as the foundation for the complete Prisma schema generation, so accuracy, normalization compliance, and completeness are critical." /* AutoBeSystemPromptConstant.PRISMA_COMPONENT */,
         },
         {
             id: (0, uuid_1.v7)(),
@@ -55,19 +55,19 @@ const transformPrismaComponentsHistories = (state, props) => {
         
         - \`mv_shopping_daily_stats\`
         
-        ${state.analyze.roles.length > 0
+        ${state.analyze.actors.length > 0
                 ? utils_1.StringUtil.trim `
-                ## User Role Handling
-                
-                The Requirement Analysis Report contains the following user roles: ${state.analyze.roles.join(", ")}
-                
-                **Do not normalize** user roles into a single table.
-                Instead, create separate tables for each distinct role mentioned in the requirements.
-                
-                Create separate tables for each role:
-                
-                ${state.analyze.roles
-                    .map((role) => `- ${props.prefix}_${role.name.toLowerCase()}`)
+                ## User Actor Handling
+
+                The Requirement Analysis Report contains the following user actors: ${state.analyze.actors.join(", ")}
+
+                **Do not normalize** user actors into a single table.
+                Instead, create separate tables for each distinct actor mentioned in the requirements.
+
+                Create separate tables for each actor:
+
+                ${state.analyze.actors
+                    .map((actor) => `- ${props.prefix}_${actor.name.toLowerCase()}`)
                     .join("\n")}
               `
                 : ""}

package/lib/orchestrate/prisma/histories/transformPrismaComponentsHistories.js.map

@@ -1 +1 @@
-{"version":3,"file":"transformPrismaComponentsHistories.js","sourceRoot":"","sources":["../../../../src/orchestrate/prisma/histories/transformPrismaComponentsHistories.ts"],"names":[],"mappings":";;;AACA,yCAA2C;AAC3C,uEAAoE;AACpE,+BAA0B;AAKnB,MAAM,kCAAkC,GAAG,CAChD,KAAkB,EAClB,KAGC,EAGD,EAAE;IACF,IAAI,KAAK,CAAC,OAAO,KAAK,IAAI;QACxB,cAAc;QACd,MAAM,IAAI,KAAK,CAAC,2BAA2B,CAAC,CAAC;IAC/C,IAAI,KAAK,CAAC,MAAM;QAAE,KAAK,CAAC,MAAM,GAAG,mCAAgB,CAAC,KAAK,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;IACtE,OAAO;QACL;YACE,EAAE,EAAE,IAAA,SAAE,GAAE;YACR,UAAU,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;YACpC,IAAI,EAAE,eAAe;YACrB,IAAI,+3dAA6C;SAClD;QACD;YACE,EAAE,EAAE,IAAA,SAAE,GAAE;YACR,UAAU,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;YACpC,IAAI,EAAE,kBAAkB;YACxB,IAAI,EAAE,kBAAU,CAAC,IAAI,CAAA;;;;;;;;;UASjB,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC;;;;;yCAKJ,KAAK,CAAC,MAAM;;;;;;;;;;;;;;;;;;;;UAqB3C,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC;gBAC5B,CAAC,CAAC,kBAAU,CAAC,IAAI,CAAA;;;qFAGwD,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC;;;;;;;kBAOjG,KAAK,CAAC,OAAO,CAAC,KAAK;qBAClB,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,KAAK,KAAK,CAAC,MAAM,IAAI,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,EAAE,CAAC;qBAC7D,IAAI,CAAC,IAAI,CAAC;eACd;gBACH,CAAC,CAAC,EACN;;;;;;;;;;;;;;;;UAgBE,KAAK,CAAC,WAAW;OACpB;SACF;KACF,CAAC;AACJ,CAAC,CAAC;AA/FW,QAAA,kCAAkC,sCA+F7C"}
+{"version":3,"file":"transformPrismaComponentsHistories.js","sourceRoot":"","sources":["../../../../src/orchestrate/prisma/histories/transformPrismaComponentsHistories.ts"],"names":[],"mappings":";;;AACA,yCAA2C;AAC3C,uEAAoE;AACpE,+BAA0B;AAKnB,MAAM,kCAAkC,GAAG,CAChD,KAAkB,EAClB,KAGC,EAGD,EAAE;IACF,IAAI,KAAK,CAAC,OAAO,KAAK,IAAI;QACxB,cAAc;QACd,MAAM,IAAI,KAAK,CAAC,2BAA2B,CAAC,CAAC;IAC/C,IAAI,KAAK,CAAC,MAAM;QAAE,KAAK,CAAC,MAAM,GAAG,mCAAgB,CAAC,KAAK,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;IACtE,OAAO;QACL;YACE,EAAE,EAAE,IAAA,SAAE,GAAE;YACR,UAAU,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;YACpC,IAAI,EAAE,eAAe;YACrB,IAAI,mi1BAA6C;SAClD;QACD;YACE,EAAE,EAAE,IAAA,SAAE,GAAE;YACR,UAAU,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;YACpC,IAAI,EAAE,kBAAkB;YACxB,IAAI,EAAE,kBAAU,CAAC,IAAI,CAAA;;;;;;;;;UASjB,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC;;;;;yCAKJ,KAAK,CAAC,MAAM;;;;;;;;;;;;;;;;;;;;UAqB3C,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC;gBAC7B,CAAC,CAAC,kBAAU,CAAC,IAAI,CAAA;;;sFAGyD,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC;;;;;;;kBAOnG,KAAK,CAAC,OAAO,CAAC,MAAM;qBACnB,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,KAAK,CAAC,MAAM,IAAI,KAAK,CAAC,IAAI,CAAC,WAAW,EAAE,EAAE,CAAC;qBAC/D,IAAI,CAAC,IAAI,CAAC;eACd;gBACH,CAAC,CAAC,EACN;;;;;;;;;;;;;;;;UAgBE,KAAK,CAAC,WAAW;OACpB;SACF;KACF,CAAC;AACJ,CAAC,CAAC;AA/FW,QAAA,kCAAkC,sCA+F7C"}