@kinotic-ai/kinotic-cli 1.0.0

package/dist/internal/converter/typescript/TypescriptConversionState.js

@@ -0,0 +1,26 @@
+import { BaseConversionState } from '../common/BaseConversionState.js';
+/**
+ * The state of the Typescript to C3Type conversion process.
+ */
+export class TypescriptConversionState extends BaseConversionState {
+    /**
+     * Contains a stack of object names for objects being processed.
+     */
+    objectNameStack = [];
+    /**
+     * Contains a stack of property names for any properties processed that are a union type.
+     */
+    unionPropertyNameStack = [];
+    /**
+     * Boolean to indicate if the source path should be added to the metadata for the {@link C3Type}s created.
+     */
+    shouldAddSourcePathToMetadata = true;
+    /**
+     * Boolean to indicate if multi-tenant selection is enabled.
+     * This is done by adding a {@link TenantId} decorator to the entity.
+     */
+    multiTenantSelectionEnabled = false;
+    constructor(application) {
+        super(application);
+    }
+}

package/dist/internal/converter/typescript/TypescriptConverterStrategy.d.ts

@@ -0,0 +1,16 @@
+import { C3Type } from '@kinotic-ai/idl';
+import { Type } from 'ts-morph';
+import { IConverterStrategy } from '../IConverterStrategy.js';
+import { Logger } from '../../Logger.js';
+import { TypescriptConversionState } from './TypescriptConversionState.js';
+import { ITypeConverter } from '../ITypeConverter.js';
+export declare class TypescriptConverterStrategy implements IConverterStrategy<Type, C3Type, TypescriptConversionState> {
+    private readonly _initialState;
+    private readonly _logger;
+    private readonly _typeConverters;
+    constructor(initialState: (() => TypescriptConversionState) | TypescriptConversionState, logger: Logger);
+    initialState(): (() => TypescriptConversionState) | TypescriptConversionState;
+    logger(): Logger | (() => Logger);
+    typeConverters(): Array<ITypeConverter<Type, C3Type, TypescriptConversionState>>;
+    valueToString(value: Type): string;
+}

package/dist/internal/converter/typescript/TypescriptConverterStrategy.js

@@ -0,0 +1,44 @@
+import { QueryOptionsToC3Type } from './QueryOptionsToC3Type.js';
+import { TenantSelectionToC3Type } from './TenantSelectionToC3Type.js';
+import { ObjectLikeToC3Type } from './ObjectLikeToC3Type.js';
+import { PrimitiveToC3Type } from './PrimitiveToC3Type.js';
+import { UnionToC3Type } from './UnionToC3Type.js';
+import { ArrayToC3Type } from './ArrayToC3Type.js';
+import { EnumToC3Type } from './EnumToC3Type.js';
+export class TypescriptConverterStrategy {
+    _initialState;
+    _logger;
+    // CAUTION: The order here is important!
+    // TenantSelection is an array, but we need the specific type
+    // QueryOptions is an object, but we need the specific type
+    // Arrays are considered objects but objects are not arrays. So the Array converter must come before the "ObjectLike" converter
+    // Enums ar considered unions but unions are not enums. So the enum converter must come before the union converter
+    _typeConverters = [new PrimitiveToC3Type(),
+        new TenantSelectionToC3Type(),
+        new QueryOptionsToC3Type(),
+        new ArrayToC3Type(),
+        new ObjectLikeToC3Type(),
+        new EnumToC3Type(),
+        new UnionToC3Type()];
+    constructor(initialState, logger) {
+        this._initialState = initialState;
+        this._logger = logger;
+    }
+    initialState() {
+        return this._initialState;
+    }
+    logger() {
+        return this._logger;
+    }
+    typeConverters() {
+        return this._typeConverters;
+    }
+    valueToString(value) {
+        // TODO: work on making this as helpful for debugging as possible
+        let ret = value?.getSymbol()?.getValueDeclaration()?.print();
+        if (!ret) {
+            ret = value.getText();
+        }
+        return ret;
+    }
+}

package/dist/internal/converter/typescript/UnionToC3Type.d.ts

@@ -0,0 +1,15 @@
+import { C3Type } from '@kinotic-ai/idl';
+import { Type } from 'ts-morph';
+import { TypescriptConversionState } from './TypescriptConversionState.js';
+import { ITypeConverter } from '../ITypeConverter.js';
+import { IConversionContext } from '../IConversionContext.js';
+/**
+ * Converts a typescript union type to a C3Type
+ */
+export declare class UnionToC3Type implements ITypeConverter<Type, C3Type, TypescriptConversionState> {
+    convert(value: Type, conversionContext: IConversionContext<Type, C3Type, TypescriptConversionState>): C3Type;
+    supports(value: Type): boolean;
+    private isPrimitive;
+    private getUnionC3TypeName;
+    private capitalizeFirstLetter;
+}

package/dist/internal/converter/typescript/UnionToC3Type.js

@@ -0,0 +1,184 @@
+import { BooleanC3Type, StringC3Type, UnionC3Type } from '@kinotic-ai/idl';
+/**
+ * Converts a typescript union type to a C3Type
+ */
+export class UnionToC3Type {
+    convert(value, conversionContext) {
+        let ret;
+        const convertedList = [];
+        let primitiveCount = 0;
+        let arrayCount = 0;
+        let enumCount = 0;
+        let booleanLiteral = false;
+        const stringLiterals = [];
+        // Unions are interesting because there are unions that are not invalid but not a union when it comes to C3
+        // For example:
+        // string | undefined | null
+        // This is not a union in C3 because it is not a union of objects
+        // Another example:
+        // let var?: string
+        // Which provides the union types of string | undefined
+        // Another example:
+        // let var?: MyEnum
+        // Which provides the union types of undefined | MyEnum.FIRST | MyEnum.SECOND ect..
+        // Another example:
+        // let var?: boolean
+        // Which provides the union types of undefined | true | false
+        value.getUnionTypes().forEach((unionType) => {
+            if (!unionType.isUndefined() && !unionType.isNull()) {
+                // Array has to be checked before object because arrays are objects
+                if (unionType.isArray()) {
+                    convertedList.push(conversionContext.convert(unionType));
+                    arrayCount++;
+                }
+                else if (unionType.isStringLiteral()) { // This must be before is primitive because string literals are primitives
+                    stringLiterals.push(unionType.getText());
+                }
+                else if (unionType.isBooleanLiteral()) { // This must be before is primitive because boolean literals are primitives
+                    booleanLiteral = true;
+                }
+                else if (this.isPrimitive(unionType)) {
+                    if (unionType.isLiteral()) {
+                        convertedList.push(conversionContext.convert(unionType.getApparentType()));
+                    }
+                    else {
+                        convertedList.push(conversionContext.convert(unionType));
+                    }
+                    primitiveCount++;
+                }
+                else if (unionType.isObject()) { // This must be after is primitive because dates are objects
+                    convertedList.push(conversionContext.convert(unionType));
+                }
+                else if (unionType.isEnumLiteral()) {
+                    // Since the enums come back as a bunch of enum literals we only convert the first one we encounter
+                    if (enumCount === 0) {
+                        const toConvert = unionType.getSymbol()?.getValueDeclaration()?.getParent()?.getType();
+                        if (toConvert) {
+                            convertedList.push(conversionContext.convert(toConvert));
+                        }
+                        else {
+                            throw new Error("Could not find the parent type of the enum literal: " + unionType.getText());
+                        }
+                    }
+                    enumCount++;
+                }
+                else {
+                    throw new Error("Union type contains a type that is not supported: " + unionType.getText());
+                }
+            }
+        });
+        if (primitiveCount > 1) {
+            throw new Error("Union type contains more than one primitive type: " + value.getText());
+        }
+        if (arrayCount > 1) {
+            throw new Error("Union type contains more than one array type: " + value.getText());
+        }
+        // Now we check that a union is only objets or is single non object type
+        // Since kinotic does not support unions of primitives, arrays, or enums
+        if (primitiveCount === 1) {
+            if (convertedList.length === 1) {
+                ret = convertedList[0];
+            }
+            else {
+                throw new Error("You cannot create a Union with a primitive type and other types: " + value.getText());
+            }
+        }
+        else if (arrayCount === 1) {
+            if (convertedList.length === 1) {
+                ret = convertedList[0];
+            }
+            else {
+                throw new Error("You cannot create a Union with an array type and other types: " + value.getText());
+            }
+        }
+        else if (enumCount >= 1) {
+            if (convertedList.length === 1) {
+                ret = convertedList[0];
+                if (ret.values.length !== enumCount) {
+                    throw new Error("There were more enums found in the union than were converted: " + value.getText() + "\n(Sorry if this error is kind of confusing, it is a bit of a edge case)");
+                }
+            }
+            else {
+                throw new Error("You cannot create a Union with an enum type and other types, or more than one enum type: " + value.getText());
+            }
+        }
+        else if (booleanLiteral) {
+            if (primitiveCount > 0 || arrayCount > 0 || enumCount > 0 || convertedList.length > 0) {
+                throw new Error("You cannot create a Union with boolean and other types: " + value.getText());
+            }
+            ret = new BooleanC3Type();
+        }
+        else if (stringLiterals.length > 0) {
+            // This handles the case of a union of string literals
+            // eg: "first" | "second" | "third"
+            // This is a special case because we want to convert it to an enum
+            // but for now we will just return a string type
+            if (primitiveCount > 0 || arrayCount > 0 || enumCount > 0 || convertedList.length > 0) {
+                throw new Error("You cannot create a Union with string literals and other types: " + value.getText());
+            }
+            // const enumType = new EnumC3Type()
+            // enumType.namespace = conversionContext.state().namespace
+            // enumType.name = this.getUnionPropertyName(conversionContext)
+            // for (const stringLiteral of stringLiterals) {
+            //     enumType.addValue(trim(stringLiteral, '"'))
+            // }
+            ret = new StringC3Type();
+        }
+        else if (convertedList.length === 1) { // In this case it was a single optional object, let myVar?: MyObject
+            ret = convertedList[0];
+        }
+        else {
+            const namespace = conversionContext.state().application;
+            const name = this.getUnionC3TypeName(value, conversionContext);
+            const unionType = new UnionC3Type(name, namespace);
+            unionType.types = convertedList;
+            ret = unionType;
+        }
+        return ret;
+    }
+    supports(value) {
+        return value.isUnion();
+    }
+    isPrimitive(type) {
+        const typeText = type.getText().toLowerCase();
+        return typeText === 'string'
+            || typeText === 'number'
+            || typeText === 'boolean'
+            || typeText === 'date'
+            || (type.isLiteral() && this.isPrimitive(type.getApparentType()));
+    }
+    getUnionC3TypeName(value, conversionContext) {
+        let ret = null;
+        // first try to get name from type.
+        const parts = value.getText(undefined, 0).split('|');
+        if (parts.length == 1) {
+            // This is a single type, so we can use the name of the type
+            ret = parts[0].trim();
+        }
+        else if (parts.length == 2) {
+            // if 2 this can be something like UnionType | undefined, or like SomeType | AnotherType
+            // Make sure one of the strings is undefined, if not this is something like SomeType | AnotherType
+            if (parts[0].trim() === 'undefined') {
+                ret = parts[1].trim();
+            }
+            else if (parts[1].trim() === 'undefined') {
+                ret = parts[0].trim();
+            }
+        }
+        if (!ret) {
+            // since we could not determine the type name above we can use the property name
+            if (conversionContext.state().unionPropertyNameStack.length > 0) {
+                const unionPropName = this.capitalizeFirstLetter(conversionContext.state().unionPropertyNameStack[conversionContext.state().unionPropertyNameStack.length - 1]);
+                const objectName = conversionContext.state().objectNameStack[conversionContext.state().objectNameStack.length - 1];
+                ret = objectName + '_' + unionPropName;
+            }
+            else {
+                throw new Error("The current property name is not set in the conversion state");
+            }
+        }
+        return ret;
+    }
+    capitalizeFirstLetter(s) {
+        return s.charAt(0).toUpperCase() + s.slice(1);
+    }
+}

package/dist/internal/state/Environment.d.ts

@@ -0,0 +1,13 @@
+export declare class ServerConfiguration {
+    name: string;
+    url: string;
+}
+export declare class Environment {
+    servers: ServerConfiguration[];
+    defaultServer: ServerConfiguration;
+    hasServer(server: string): boolean;
+    findServer(server: string): ServerConfiguration | null;
+}
+export declare function loadEnvironment(dataDir: string): Promise<Environment>;
+export declare function saveEnvironment(dataDir: string, environment: Environment): Promise<void>;
+export declare function resolveServer(dataDir: string, server?: string | null): Promise<ServerConfiguration>;

package/dist/internal/state/Environment.js

@@ -0,0 +1,65 @@
+import { createStateManager } from './IStateManager.js';
+const ENVIRONMENT_KEY = 'kinotic-environment';
+export class ServerConfiguration {
+    name;
+    url;
+}
+export class Environment {
+    servers = [];
+    defaultServer;
+    hasServer(server) {
+        return this.findServer(server) !== null;
+    }
+    findServer(server) {
+        let ret = null;
+        for (const serverConfig of this.servers) {
+            if (serverConfig.name === server
+                || serverConfig.url === server) {
+                ret = serverConfig;
+                break;
+            }
+        }
+        return ret;
+    }
+}
+export async function loadEnvironment(dataDir) {
+    const stateManager = createStateManager(dataDir);
+    if (await stateManager.containsState(ENVIRONMENT_KEY)) {
+        const jsonEnv = await stateManager.load(ENVIRONMENT_KEY);
+        const ret = new Environment(); // we do this to ensure that the object has the correct prototype
+        if (jsonEnv.servers) {
+            ret.servers = jsonEnv.servers;
+        }
+        ret.defaultServer = jsonEnv.defaultServer;
+        return ret;
+    }
+    else {
+        return new Environment();
+    }
+}
+export async function saveEnvironment(dataDir, environment) {
+    const stateManager = createStateManager(dataDir);
+    await stateManager.save(ENVIRONMENT_KEY, environment);
+}
+export async function resolveServer(dataDir, server) {
+    const environment = await loadEnvironment(dataDir);
+    let ret;
+    if (server) {
+        ret = environment.findServer(server);
+        if (ret === null) {
+            ret = new ServerConfiguration();
+            ret.name = server;
+            ret.url = server;
+            environment.servers.push(ret);
+            environment.defaultServer = ret;
+            await saveEnvironment(dataDir, environment);
+        }
+    }
+    else {
+        if (!environment.defaultServer) {
+            throw new Error("No Default Server configured. Please specify a Server or set a Default Server.");
+        }
+        ret = environment.defaultServer;
+    }
+    return ret;
+}

package/dist/internal/state/IStateManager.d.ts

@@ -0,0 +1,19 @@
+export interface IStateManager {
+    /**
+     * Checks if the state manager contains a state for the given key
+     * @param key the key to check for
+     */
+    containsState(key: string): Promise<boolean>;
+    /**
+     * Saves the given state to the state manager
+     * @param key the key to save the state under
+     * @param state the state to save
+     */
+    save<T>(key: string, state: T): Promise<void>;
+    /**
+     * Loads the state for the given key
+     * @param key the key to load the state for
+     */
+    load<T>(key: string): Promise<T>;
+}
+export declare function createStateManager(dataDir: string): IStateManager;

package/dist/internal/state/IStateManager.js

@@ -0,0 +1,41 @@
+import fsPromises from 'fs/promises';
+import fs from 'fs';
+import path from 'path';
+class DefaultStateManager {
+    dataDir;
+    constructor(dataDir) {
+        this.dataDir = dataDir;
+    }
+    async containsState(key) {
+        const filePath = path.resolve(this.dataDir, `${key}.json`);
+        if (fs.existsSync(filePath)) {
+            return Promise.resolve(true);
+        }
+        else {
+            return Promise.resolve(false);
+        }
+    }
+    async load(key) {
+        const filePath = path.resolve(this.dataDir, `${key}.json`);
+        if (fs.existsSync(filePath)) {
+            const data = await fsPromises.readFile(filePath, { encoding: 'utf-8' });
+            try {
+                return JSON.parse(data);
+            }
+            catch (e) {
+                return Promise.reject('Failed to parse JSON for filePath: ' + filePath + '\n' + e);
+            }
+        }
+        else {
+            return Promise.reject('State not found for key: ' + key);
+        }
+    }
+    async save(key, state) {
+        const filePath = path.resolve(this.dataDir, `${key}.json`);
+        await fsPromises.mkdir(path.dirname(filePath), { recursive: true });
+        return fsPromises.writeFile(filePath, JSON.stringify(state, null, 2));
+    }
+}
+export function createStateManager(dataDir) {
+    return new DefaultStateManager(dataDir);
+}

package/dist/internal/state/KinoticProjectConfigUtil.d.ts

@@ -0,0 +1,9 @@
+import type { KinoticProjectConfig } from '@kinotic-ai/core';
+/**
+ * Saves a KinoticProjectConfig to the .config directory using the appropriate Liquid template.
+ * @param config The config object to save
+ * @param configDir The directory to save the config file in (usually .config)
+ */
+export declare function saveKinoticProjectConfig(config: KinoticProjectConfig, configDir: string): Promise<void>;
+export declare function isKinoticProject(): Promise<boolean>;
+export declare function loadKinoticProjectConfig(): Promise<KinoticProjectConfig>;

package/dist/internal/state/KinoticProjectConfigUtil.js

@@ -0,0 +1,153 @@
+import { loadConfig } from 'c12';
+import path from 'path';
+import fsPromises from 'fs/promises';
+import { Liquid } from 'liquidjs';
+import { fileURLToPath } from 'url';
+/**
+ * Returns the absolute path to the first supported kinotic.config.* file in the .config directory, or undefined if none found.
+ */
+async function findKinoticConfigFile() {
+    const configDir = path.resolve(process.cwd(), '.config');
+    try {
+        const stat = await fsPromises.stat(configDir);
+        if (stat.isDirectory()) {
+            const files = await fsPromises.readdir(configDir);
+            const supported = files.filter(f => f.startsWith('kinotic.config.'));
+            if (supported.length > 0) {
+                return path.join(configDir, supported[0]);
+            }
+        }
+    }
+    catch (e) {
+        // Directory does not exist or is not accessible
+    }
+    return undefined;
+}
+/**
+ * Helper function to render a value as TypeScript code with proper indentation
+ */
+function renderValue(value, indent = 0) {
+    const indentStr = '  '.repeat(indent);
+    const nextIndentStr = '  '.repeat(indent + 1);
+    if (value === null) {
+        return 'null';
+    }
+    if (value === undefined) {
+        return 'undefined';
+    }
+    if (typeof value === 'boolean') {
+        return String(value);
+    }
+    if (typeof value === 'string') {
+        // JSON.stringify produces a valid JS/TS string literal with correct escaping
+        // (handles backslashes, quotes, newlines, tabs, etc.)
+        return JSON.stringify(value);
+    }
+    if (typeof value === 'number') {
+        return String(value);
+    }
+    if (Array.isArray(value)) {
+        if (value.length === 0) {
+            return '[]';
+        }
+        const items = value.map(item => `${nextIndentStr}${renderValue(item, indent + 1)}`).join(',\n');
+        return `[\n${items}\n${indentStr}]`;
+    }
+    if (typeof value === 'object') {
+        const entries = Object.entries(value)
+            .filter(([key, val]) => val !== undefined); // Only filter out undefined values
+        if (entries.length === 0) {
+            return '{}';
+        }
+        const props = entries
+            .map(([key, val]) => `${nextIndentStr}${key}: ${renderValue(val, indent + 1)}`)
+            .join(',\n');
+        return `{\n${props}\n${indentStr}}`;
+    }
+    return 'undefined';
+}
+/**
+ * Saves a KinoticProjectConfig to the .config directory using the appropriate Liquid template.
+ * @param config The config object to save
+ * @param configDir The directory to save the config file in (usually .config)
+ */
+export async function saveKinoticProjectConfig(config, configDir) {
+    const engine = new Liquid({
+        root: path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../../templates/'),
+        extname: '.liquid'
+    });
+    // Register custom tags for rendering config values
+    engine.registerTag('render_value', {
+        parse: function (tagToken) {
+            const args = tagToken.args.trim().split(/\s+/);
+            this.value = args[0];
+            this.indent = args[1] || '0'; // Default indent to 0
+        },
+        render: function* (ctx) {
+            const value = yield engine.evalValue(this.value, ctx);
+            const indentLevel = yield engine.evalValue(this.indent, ctx);
+            return renderValue(value, indentLevel || 0);
+        }
+    });
+    const outFile = path.join(configDir, 'kinotic.config.ts');
+    const templateFile = 'KinoticProjectConfig.ts.liquid';
+    const renderContext = { config };
+    try {
+        await fsPromises.mkdir(configDir);
+    }
+    catch (e) {
+        // Directory may already exist
+    }
+    const fileContent = await engine.renderFile(templateFile, renderContext);
+    await fsPromises.writeFile(outFile, fileContent);
+}
+export async function isKinoticProject() {
+    let result = false;
+    if (await findKinoticConfigFile()) {
+        result = true;
+    }
+    return result;
+}
+export async function loadKinoticProjectConfig() {
+    let result;
+    const configFile = await findKinoticConfigFile();
+    let configDir = path.resolve(process.cwd(), '.config');
+    if (configFile) {
+        configDir = path.dirname(configFile);
+        const { config } = await loadConfig({
+            configFile: configFile,
+            name: 'kinotic',
+            cwd: configDir,
+            dotenv: false,
+            packageJson: false
+        });
+        if (!config) {
+            throw new Error(`Failed to load config from ${configFile}`);
+        }
+        result = config;
+    }
+    if (!result) {
+        throw new Error('No kinotic project config found and not a legacy project');
+    }
+    // If name is not set, try to load from package.json in cwd
+    if (!result.name || !result.description) {
+        try {
+            const pkgPath = path.resolve(process.cwd(), 'package.json');
+            const pkgRaw = await fsPromises.readFile(pkgPath, 'utf-8');
+            const pkg = JSON.parse(pkgRaw);
+            if (!result.name && pkg.name) {
+                result.name = pkg.name;
+            }
+            else {
+                throw new Error('No "name" field found in package.json. Please set the name in your KinoticProjectConfig or package.json.');
+            }
+            if (!result.description && pkg.description) {
+                result.description = pkg.description;
+            }
+        }
+        catch (e) {
+            throw new Error('Could not determine project name. Please set the name in your KinoticProjectConfig.\nOriginal error: ' + (e instanceof Error ? e.message : String(e)));
+        }
+    }
+    return result;
+}

package/dist/templates/AdminEntityService.liquid

@@ -0,0 +1,14 @@
+import { type IAdminEntitiesService } from '@kinotic-ai/persistence'
+import { Base{{ entityName }}AdminEntityService } from './generated/Base{{ entityName }}AdminEntityService{{ fileExtensionForImports }}'
+
+/**
+ * Admin Service for interacting with {{ entityName }} entities
+ * This class was generated by the Kinotic CLI
+ */
+export class {{ entityName }}AdminEntityService extends Base{{ entityName }}AdminEntityService {
+
+  constructor(adminEntitiesService?: IAdminEntitiesService) {
+    super(adminEntitiesService)
+  }
+
+}

package/dist/templates/BaseAdminEntityService.liquid

@@ -0,0 +1,19 @@
+import { AdminEntityService, type IAdminEntitiesService } from '@kinotic-ai/persistence'
+{%- if defaultExport == true %}
+import {{ entityName }} from '{{ entityImportPath }}'
+{%- else %}
+import { {{ entityName }} } from '{{ entityImportPath }}'
+{%- endif %}
+{{ importStatements }}
+
+/**
+ * Admin Base Service for interacting with {{ entityName }} entities
+ * This class was generated by the Kinotic CLI. And will be overwritten if the CLI is run again.
+ */
+export class Base{{ entityName }}AdminEntityService extends AdminEntityService<{{ entityName }}> {
+
+  constructor(adminEntitiesService?: IAdminEntitiesService) {
+    super('{{ entityNamespace }}', '{{ entityName }}', adminEntitiesService)
+  }
+
+}

package/dist/templates/BaseEntityService.liquid

@@ -0,0 +1,48 @@
+import { EntityService, type IEntitiesService } from '@kinotic-ai/persistence'
+{%- if defaultExport == true %}
+import {{ entityName }} from '{{ entityImportPath }}'
+{%- else %}
+import { {{ entityName }} } from '{{ entityImportPath }}'
+{%- endif %}
+{{ importStatements }}
+
+/**
+ * Base Service for interacting with {{ entityName }} entities
+ * This class was generated by the Kinotic CLI. And will be overwritten if the CLI is run again.
+ */
+export class Base{{ entityName }}EntityService extends EntityService<{{ entityName }}> {
+
+  private readonly shouldValidate: boolean
+
+  constructor(shouldValidate: boolean = true, entitiesService?: IEntitiesService) {
+    super('{{ entityNamespace }}', '{{ entityName }}', entitiesService)
+    this.shouldValidate = shouldValidate
+  }
+
+  protected async beforeSaveOrUpdate(entity: {{ entityName }}): Promise<{{ entityName }}> {
+    if (this.shouldValidate) {
+      return this.validate(entity)
+    } else {
+      return entity
+    }
+  }
+
+  protected async beforeBulkSaveOrUpdate(entities: {{ entityName }}[]): Promise<{{ entityName }}[]> {
+    if (this.shouldValidate) {
+      const validatedEntities: {{ entityName }}[] = []
+      for (let entity of entities) {
+        validatedEntities.push(this.validate(entity))
+      }
+      return validatedEntities
+    } else {
+      return entities
+    }
+  }
+
+  validate(entity: {{ entityName }}): {{ entityName }} {
+    let ret: any
+{{ validationLogic }}
+    return ret
+  }
+
+}