dscaffold/dist/generators/SchemaGenerator.js

A TypeScript framework for scaffolding modular Discord bot projects with dynamic command and event loading

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.SchemaGenerator = void 0;
const path_1 = __importDefault(require("path"));
const utils_1 = require("../utils");
const TemplateRenderer_1 = require("./TemplateRenderer");
class SchemaGenerator {
    constructor(config) {
        this.config = config;
        this.templateRenderer = new TemplateRenderer_1.TemplateRenderer();
    }
    async generate(targetPath) {
        // Determine if project uses TypeScript
        const tsConfigExists = await (0, utils_1.pathExists)(path_1.default.join(targetPath, 'tsconfig.json'));
        const extension = tsConfigExists ? 'ts' : 'js';
        const modelsDir = path_1.default.join(targetPath, 'src', 'models');
        await (0, utils_1.ensureDir)(modelsDir);
        const filePath = path_1.default.join(modelsDir, `${this.config.name}.${extension}`);
        let template;
        switch (this.config.type) {
            case 'mongoose':
                template = tsConfigExists ? this.getMongooseTypeScriptTemplate() : this.getMongooseJavaScriptTemplate();
                break;
            case 'prisma':
                template = this.getPrismaTemplate();
                break;
            case 'sequelize':
                template = tsConfigExists ? this.getSequelizeTypeScriptTemplate() : this.getSequelizeJavaScriptTemplate();
                break;
            default:
                throw new Error(`Unknown schema type: ${this.config.type}`);
        }
        const content = this.templateRenderer.render(template, {
            name: this.config.name,
            className: (0, utils_1.toPascalCase)(this.config.name),
            fields: this.config.fields,
        });
        await (0, utils_1.writeFile)(filePath, content);
    }
    getMongooseTypeScriptTemplate() {
        return `import mongoose, { Document, Schema } from 'mongoose';

export interface I{{className}} extends Document {
{{#fields}}
  {{name}}: {{#convertMongooseType}}{{type}}{{/convertMongooseType}};
{{/fields}}
}

const {{className}}Schema: Schema = new Schema({
{{#fields}}
  {{name}}: {
    type: {{#convertMongooseType}}{{type}}{{/convertMongooseType}},
    required: {{required}},
  },
{{/fields}}
}, {
  timestamps: true,
});

export const {{className}} = mongoose.model<I{{className}}>('{{className}}', {{className}}Schema);
`;
    }
    getMongooseJavaScriptTemplate() {
        return `const mongoose = require('mongoose');

const {{className}}Schema = new mongoose.Schema({
{{#fields}}
  {{name}}: {
    type: {{#convertMongooseType}}{{type}}{{/convertMongooseType}},
    required: {{required}},
  },
{{/fields}}
}, {
  timestamps: true,
});

module.exports = mongoose.model('{{className}}', {{className}}Schema);
`;
    }
    getPrismaTemplate() {
        return `// Add this to your Prisma schema file (schema.prisma)

model {{className}} {
{{#fields}}
  {{name}} {{#convertPrismaType}}{{type}}{{/convertPrismaType}}{{#required}}{{/required}}{{^required}}?{{/required}}
{{/fields}}
  createdAt DateTime @default(now())
  updatedAt DateTime @updatedAt
}
`;
    }
    getSequelizeTypeScriptTemplate() {
        return `import { DataTypes, Model, Optional } from 'sequelize';
import { sequelize } from '../config/database';

interface {{className}}Attributes {
{{#fields}}
  {{name}}: {{#convertSequelizeType}}{{type}}{{/convertSequelizeType}};
{{/fields}}
}

interface {{className}}CreationAttributes extends Optional<{{className}}Attributes, 'id'> {}

class {{className}} extends Model<{{className}}Attributes, {{className}}CreationAttributes> 
  implements {{className}}Attributes {
{{#fields}}
  public {{name}}!: {{#convertSequelizeType}}{{type}}{{/convertSequelizeType}};
{{/fields}}

  public readonly createdAt!: Date;
  public readonly updatedAt!: Date;
}

{{className}}.init(
  {
{{#fields}}
    {{name}}: {
      type: DataTypes.{{#convertSequelizeDataType}}{{type}}{{/convertSequelizeDataType}},
      allowNull: {{^required}}true{{/required}}{{#required}}false{{/required}},
    },
{{/fields}}
  },
  {
    sequelize,
    modelName: '{{className}}',
  }
);

export { {{className}} };
`;
    }
    getSequelizeJavaScriptTemplate() {
        return `const { DataTypes } = require('sequelize');
const { sequelize } = require('../config/database');

const {{className}} = sequelize.define('{{className}}', {
{{#fields}}
  {{name}}: {
    type: DataTypes.{{#convertSequelizeDataType}}{{type}}{{/convertSequelizeDataType}},
    allowNull: {{^required}}true{{/required}}{{#required}}false{{/required}},
  },
{{/fields}}
});

module.exports = {{className}};
`;
    }
}
exports.SchemaGenerator = SchemaGenerator;
//# sourceMappingURL=SchemaGenerator.js.map