@promakeai/orm 1.0.4 → 1.0.6

package/dist/index.d.ts

@@ -46,7 +46,8 @@ export { buildTranslationQuery, buildTranslationQueryById, buildTranslationInser
 export type { TranslationQueryOptions, TranslationQueryResult, } from "./utils/translationQuery";
 export { resolvePopulate, getPopulatableFields, validatePopulate, } from "./utils/populateResolver";
 export type { PopulateAdapter } from "./utils/populateResolver";
-export { parseJSONSchema } from "./utils/jsonConverter";
+export { parseJSONSchema, parseJSONSchemaWithWarnings, } from "./utils/jsonConverter";
+export type { ParseJSONSchemaResult } from "./utils/jsonConverter";
 export { isJsonType } from "./types";
 export { deserializeRow, serializeRow } from "./utils/deserializer";
 export type { FieldType, FieldDefinition, FieldReference, FieldBuilderLike, TableDefinition, LanguageConfig, SchemaDefinition, SchemaInput, JSONFieldType, JSONFieldDefinition, JSONTableDefinition, JSONSchemaDefinition, WhereCondition, OrderByOption, PopulateOption, PopulateNested, QueryOptions, PaginatedResult, ORMConfig, } from "./types";

package/dist/index.js

@@ -1008,10 +1008,25 @@ function extractTranslatableData(data, tableSchema) {
   return { mainData, translatableData };
 }
 // src/utils/jsonConverter.ts
+var LANGUAGE_NAME_TO_CODE = {
+  english: "en",
+  turkish: "tr",
+  german: "de",
+  french: "fr",
+  spanish: "es",
+  russian: "ru",
+  arabic: "ar"
+};
 function parseJSONSchema(json) {
+  return parseJSONSchemaWithWarnings(json).schema;
+}
+function parseJSONSchemaWithWarnings(json) {
+  const warnings = [];
+  const supported = (json.languages || ["en"]).map((lang) => normalizeLangToken(lang));
+  const defaultLanguage = resolveDefaultLanguage(json.defaultLanguage, supported, warnings);
   const languages = {
-    default: json.defaultLanguage || json.languages[0] || "en",
-    supported: json.languages || ["en"]
+    default: defaultLanguage,
+    supported
   };
   const tables = {};
   for (const [tableName, jsonTable] of Object.entries(json.tables)) {
@@ -1025,11 +1040,59 @@ function parseJSONSchema(json) {
     };
   }
   return {
-    name: json.name,
-    languages,
-    tables
+    schema: {
+      name: json.name,
+      languages,
+      tables
+    },
+    warnings
   };
 }
+function normalizeLangToken(lang) {
+  return String(lang).trim().toLowerCase();
+}
+function resolveDefaultLanguage(input, supported, warnings) {
+  const fallback = supported[0] || "en";
+  if (!input)
+    return fallback;
+  const normalizedInput = normalizeLangToken(input);
+  const directMatch = supported.find((lang) => normalizeLangToken(lang) === normalizedInput);
+  if (directMatch)
+    return directMatch;
+  const languageNameMatch = resolveLanguageNameToSupportedCode(normalizedInput, supported);
+  if (languageNameMatch) {
+    warnings.push(`Normalized defaultLanguage "${input}" to "${languageNameMatch}".`);
+    return languageNameMatch;
+  }
+  throw new Error(`Invalid defaultLanguage "${input}". Expected one of: ${supported.join(", ")}`);
+}
+function resolveLanguageNameToSupportedCode(normalizedInput, supported) {
+  const mapped = LANGUAGE_NAME_TO_CODE[normalizedInput];
+  if (mapped) {
+    const supportedMatch = supported.find((lang) => normalizeLangToken(lang) === mapped);
+    if (supportedMatch)
+      return supportedMatch;
+  }
+  for (const code of supported) {
+    const languageName = getLanguageDisplayName(code);
+    if (languageName && normalizeLangToken(languageName) === normalizedInput) {
+      return code;
+    }
+  }
+  return null;
+}
+function getLanguageDisplayName(code) {
+  try {
+    if (typeof Intl === "undefined" || !("DisplayNames" in Intl)) {
+      return null;
+    }
+    const displayNames = new Intl.DisplayNames(["en"], { type: "language" });
+    const label = displayNames.of(code);
+    return label || null;
+  } catch {
+    return null;
+  }
+}
 function normalizeJsonType(type) {
   if (Array.isArray(type)) {
     const first = type[0];
@@ -1133,6 +1196,7 @@ export {
   serializeRow,
   resolvePopulate,
   pluralize,
+  parseJSONSchemaWithWarnings,
   parseJSONSchema,
   mergeSchemas,
   isValidSchema,

package/dist/utils/jsonConverter.d.ts

@@ -5,6 +5,10 @@
  * Enables AI agents to work with JSON while maintaining type-safe internal representation.
  */
 import type { JSONSchemaDefinition, SchemaDefinition } from "../types";
+export interface ParseJSONSchemaResult {
+    schema: SchemaDefinition;
+    warnings: string[];
+}
 /**
  * Convert JSON schema to internal SchemaDefinition
  *
@@ -27,3 +31,4 @@ import type { JSONSchemaDefinition, SchemaDefinition } from "../types";
  * ```
  */
 export declare function parseJSONSchema(json: JSONSchemaDefinition): SchemaDefinition;
+export declare function parseJSONSchemaWithWarnings(json: JSONSchemaDefinition): ParseJSONSchemaResult;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@promakeai/orm",
-  "version": "1.0.4",
+  "version": "1.0.6",
   "description": "Database-agnostic ORM core - works in browser and Node.js",
   "type": "module",
   "main": "./dist/index.js",

package/src/index.ts

@@ -113,8 +113,12 @@ export {
 } from "./utils/populateResolver";
 export type { PopulateAdapter } from "./utils/populateResolver";
 
-// JSON Schema Converter
-export { parseJSONSchema } from "./utils/jsonConverter";
+// JSON Schema Converter
+export {
+  parseJSONSchema,
+  parseJSONSchemaWithWarnings,
+} from "./utils/jsonConverter";
+export type { ParseJSONSchemaResult } from "./utils/jsonConverter";
 
 // Type Helpers
 export { isJsonType } from "./types";

package/src/utils/jsonConverter.ts

@@ -5,7 +5,7 @@
  * Enables AI agents to work with JSON while maintaining type-safe internal representation.
  */
 
-import type {
+import type {
   JSONSchemaDefinition,
   JSONFieldDefinition,
   JSONFieldType,
@@ -13,8 +13,23 @@ import type {
   FieldDefinition,
   FieldType,
   TableDefinition,
-  LanguageConfig,
-} from "../types";
+  LanguageConfig,
+} from "../types";
+
+const LANGUAGE_NAME_TO_CODE: Record<string, string> = {
+  english: "en",
+  turkish: "tr",
+  german: "de",
+  french: "fr",
+  spanish: "es",
+  russian: "ru",
+  arabic: "ar",
+};
+
+export interface ParseJSONSchemaResult {
+  schema: SchemaDefinition;
+  warnings: string[];
+}
 
 /**
  * Convert JSON schema to internal SchemaDefinition
@@ -37,11 +52,25 @@ import type {
  * const schema = parseJSONSchema(jsonSchema);
  * ```
  */
-export function parseJSONSchema(json: JSONSchemaDefinition): SchemaDefinition {
-  const languages: LanguageConfig = {
-    default: json.defaultLanguage || json.languages[0] || "en",
-    supported: json.languages || ["en"],
-  };
+export function parseJSONSchema(json: JSONSchemaDefinition): SchemaDefinition {
+  return parseJSONSchemaWithWarnings(json).schema;
+}
+
+export function parseJSONSchemaWithWarnings(
+  json: JSONSchemaDefinition
+): ParseJSONSchemaResult {
+  const warnings: string[] = [];
+  const supported = (json.languages || ["en"]).map((lang) => normalizeLangToken(lang));
+  const defaultLanguage = resolveDefaultLanguage(
+    json.defaultLanguage,
+    supported,
+    warnings
+  );
+
+  const languages: LanguageConfig = {
+    default: defaultLanguage,
+    supported,
+  };
 
   const tables: Record<string, TableDefinition> = {};
 
@@ -58,12 +87,84 @@ export function parseJSONSchema(json: JSONSchemaDefinition): SchemaDefinition {
     };
   }
 
-  return {
-    name: json.name,
-    languages,
-    tables,
-  };
-}
+  return {
+    schema: {
+      name: json.name,
+      languages,
+      tables,
+    },
+    warnings,
+  };
+}
+
+function normalizeLangToken(lang: string): string {
+  return String(lang).trim().toLowerCase();
+}
+
+function resolveDefaultLanguage(
+  input: string | undefined,
+  supported: string[],
+  warnings: string[]
+): string {
+  const fallback = supported[0] || "en";
+  if (!input) return fallback;
+
+  const normalizedInput = normalizeLangToken(input);
+  const directMatch = supported.find(
+    (lang) => normalizeLangToken(lang) === normalizedInput
+  );
+  if (directMatch) return directMatch;
+
+  const languageNameMatch = resolveLanguageNameToSupportedCode(
+    normalizedInput,
+    supported
+  );
+  if (languageNameMatch) {
+    warnings.push(
+      `Normalized defaultLanguage "${input}" to "${languageNameMatch}".`
+    );
+    return languageNameMatch;
+  }
+
+  throw new Error(
+    `Invalid defaultLanguage "${input}". Expected one of: ${supported.join(", ")}`
+  );
+}
+
+function resolveLanguageNameToSupportedCode(
+  normalizedInput: string,
+  supported: string[]
+): string | null {
+  const mapped = LANGUAGE_NAME_TO_CODE[normalizedInput];
+  if (mapped) {
+    const supportedMatch = supported.find(
+      (lang) => normalizeLangToken(lang) === mapped
+    );
+    if (supportedMatch) return supportedMatch;
+  }
+
+  for (const code of supported) {
+    const languageName = getLanguageDisplayName(code);
+    if (languageName && normalizeLangToken(languageName) === normalizedInput) {
+      return code;
+    }
+  }
+
+  return null;
+}
+
+function getLanguageDisplayName(code: string): string | null {
+  try {
+    if (typeof Intl === "undefined" || !("DisplayNames" in Intl)) {
+      return null;
+    }
+    const displayNames = new Intl.DisplayNames(["en"], { type: "language" });
+    const label = displayNames.of(code);
+    return label || null;
+  } catch {
+    return null;
+  }
+}
 
 /**
  * Normalize JSON-native type syntax to internal FieldType + properties