@an5/orm 1.2.0 → 1.3.1

package/dist/generator/src/index.js

@@ -13,6 +13,9 @@ const python_generator_1 = require("./python-generator");
 const dotnet_generator_1 = require("./dotnet-generator");
 const golang_generator_1 = require("./golang-generator");
 const rust_generator_1 = require("./rust-generator");
+const java_generator_1 = require("./java-generator");
+const kotlin_generator_1 = require("./kotlin-generator");
+const swift_generator_1 = require("./swift-generator");
 const fs_1 = __importDefault(require("fs"));
 function clearGeneratedFiles(outputDir, extension) {
     if (!fs_1.default.existsSync(outputDir)) {
@@ -70,6 +73,9 @@ async function main() {
     const outputDotnetDir = config.outputs.dotnetDir;
     const outputGolangDir = config.outputs.golangDir;
     const outputRustDir = config.outputs.rustDir;
+    const outputJavaDir = config.outputs.javaDir;
+    const outputKotlinDir = config.outputs.kotlinDir;
+    const outputSwiftDir = config.outputs.swiftDir;
     const generateMetadata = config.config.generation.generateMetadata;
     console.log('🚀 Starting ORM generation...');
     // The target provider comes from the connection string: both the allowed
@@ -81,6 +87,9 @@ async function main() {
         clearGeneratedFiles(outputDotnetDir, '.cs');
         clearGeneratedFiles(outputGolangDir, '.go');
         clearGeneratedFiles(path_1.default.join(outputRustDir, 'src'), '.rs');
+        clearGeneratedFiles(outputJavaDir, '.java');
+        clearGeneratedFiles(outputKotlinDir, '.kt');
+        clearGeneratedFiles(path_1.default.join(outputSwiftDir, 'Sources'), '.swift');
         const pythonDirEarly = path_1.default.dirname(outputPythonMetadataPath);
         clearGeneratedPythonFiles(pythonDirEarly);
         if (config.config.generation.generateMetadata && fs_1.default.existsSync(outputMetadataPath)) {
@@ -120,6 +129,15 @@ async function main() {
         const rustGen = new rust_generator_1.RustGenerator(outputRustDir);
         rustGen.generate(models);
         console.log(`✨ Generated Rust client in ${outputRustDir}`);
+        const javaGen = new java_generator_1.JavaGenerator(outputJavaDir);
+        javaGen.generate(models);
+        console.log(`✨ Generated Java client in ${outputJavaDir}`);
+        const kotlinGen = new kotlin_generator_1.KotlinGenerator(outputKotlinDir);
+        kotlinGen.generate(models);
+        console.log(`✨ Generated Kotlin client in ${outputKotlinDir}`);
+        const swiftGen = new swift_generator_1.SwiftGenerator(outputSwiftDir);
+        swiftGen.generate(models);
+        console.log(`✨ Generated Swift client in ${outputSwiftDir}`);
         console.log('✅ ORM generation completed successfully.');
     }
     catch (error) {

package/dist/generator/src/java-generator.d.ts

@@ -0,0 +1,56 @@
+import { Model } from './types';
+export declare class JavaGenerator {
+    private outputDir;
+    /** The database being generated for; decides types like `TIMESTAMP`. */
+    private provider;
+    constructor(outputDir: string);
+    generate(models: Model[]): void;
+    private capitalize;
+    /**
+     * The Java field name for a schema column.
+     *
+     * A field named `class`, `new` or `from` would not compile as an identifier, so those are
+     * suffixed rather than left to fail at the call site.
+     */
+    private fieldName;
+    private getterName;
+    private static toCamelCase;
+    private static toLowerCamelCase;
+    /**
+     * Every spelling of a model name the client registers it under.
+     *
+     * The metadata is keyed in camelCase while the model class is PascalCase, and the adapter
+     * resolves the difference; these are the names the context exposes so either spelling
+     * works at the call site.
+     */
+    private propertyNames;
+    /**
+     * The Java type for a column.
+     *
+     * Driven by the declared type, so a `DECIMAL` column is a `BigDecimal` and not an `int`:
+     * both arrive from the parser as `number`, which is how the earlier clients turned
+     * decimal money into integers.
+     */
+    private mapType;
+    /**
+     * The boxed form used in a model.
+     *
+     * Every field is boxed, primitives included: `toValues` skips the columns left null, and a
+     * column the schema does not mark optional can still read NULL until a row is written. A
+     * primitive cannot represent "unset", so the skip would have to give the column a default
+     * and quietly write it.
+     */
+    private mapNullableType;
+    private getFilterType;
+    private generateModels;
+    private modelSource;
+    /** The expression that reads one column into its field. */
+    private readExpression;
+    private generateValues;
+    private generateOrmTypes;
+    private generateMetadata;
+    private generateConfig;
+    private modelClientSource;
+    private generateDbContext;
+    private tableName;
+}