@postxl/generator 0.0.1

package/README.md

@@ -0,0 +1,3 @@
+# PXL Generator
+
+A utility package that lets you move quickly and generate basic components of your app easily.

package/dist/jest.config.d.ts

@@ -0,0 +1,3 @@
+import type { Config } from 'jest';
+declare const config: Config;
+export default config;

package/dist/src/generator.d.ts

@@ -0,0 +1,12 @@
+import { Logger } from './lib/utils/logger';
+import * as Schema from './lib/schema/schema';
+/**
+ * Generates PXL files and flushes them to disk.
+ */
+export declare const generate: ({ models, enums, config, prismaClientPath, logger, }: {
+    models: Schema.Model[];
+    enums: Schema.Enum[];
+    config: Schema.SchemaConfig;
+    prismaClientPath: string;
+    logger: Logger;
+}) => Promise<void>;

package/dist/src/generator.js

@@ -0,0 +1,164 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generate = void 0;
+const generator_helper_1 = require("@prisma/generator-helper");
+const internals_1 = require("@prisma/internals");
+const prettier = __importStar(require("prettier"));
+const client_path_1 = require("./prisma/client-path");
+const parse_1 = require("./prisma/parse");
+const meta_1 = require("./lib/meta");
+const vfs_1 = require("./lib/vfs");
+const route_generator_1 = require("./generators/models/route.generator");
+const repository_generator_1 = require("./generators/models/repository.generator");
+const stub_generator_1 = require("./generators/models/stub.generator");
+const seed_generator_1 = require("./generators/models/seed.generator");
+const react_generator_1 = require("./generators/models/react.generator");
+const types_generator_1 = require("./generators/models/types.generator");
+const types_generator_2 = require("./generators/enums/types.generator");
+const react_generator_2 = require("./generators/enums/react.generator");
+const datamockmodule_generator_1 = require("./generators/indices/datamockmodule.generator");
+const dataservice_generator_1 = require("./generators/indices/dataservice.generator");
+const datamodule_generator_1 = require("./generators/indices/datamodule.generator");
+const types_1 = require("./lib/schema/types");
+const faker_1 = require("@faker-js/faker");
+const repositories_generator_1 = require("./generators/indices/repositories.generator");
+const stubs_generator_1 = require("./generators/indices/stubs.generator");
+const seed_generator_2 = require("./generators/indices/seed.generator");
+const types_generator_3 = require("./generators/indices/types.generator");
+const testdataservice_generator_1 = require("./generators/indices/testdataservice.generator");
+(0, generator_helper_1.generatorHandler)({
+    onManifest() {
+        internals_1.logger.info(`PXL Registered`);
+        return {
+            version: '1.0.0',
+            defaultOutput: '../generated',
+            prettyName: `PXL`,
+        };
+    },
+    onGenerate: ({ generator, otherGenerators, dmmf }) => __awaiter(void 0, void 0, void 0, function* () {
+        internals_1.logger.info(`PXL started generating code...`);
+        const prismaClientPath = (0, client_path_1.getClientImportPath)(otherGenerators);
+        const config = {
+            project: generator.config['project'] || 'pxl',
+            paths: {
+                dataLibPath: (0, types_1.toPath)(generator.config['pathToDataLib'] || 'repos'),
+                reactFolderPath: (0, types_1.toPath)(generator.config['reactFolderOutput'] || 'react'),
+                modelTypeDefinitionsPath: (0, types_1.toPath)(generator.config['pathToTypes'] || 'types'),
+                seedPath: (0, types_1.toPath)(generator.config['pathToSeedLib'] || 'seed'),
+                trpcRoutesFolderPath: (0, types_1.toPath)(generator.config['trpcRoutesFolder'] || 'trpc'),
+            },
+            randomSeed: parseInt(generator.config['randomSeed']) || 1,
+            force: generator.config['force'] === 'true',
+        };
+        internals_1.logger.log(`Parsing DMMF...`);
+        const { models, enums } = (0, parse_1.parsePrismaSchema)({ datamodel: dmmf.datamodel, config });
+        internals_1.logger.log(`Generating...`);
+        yield (0, exports.generate)({ models, enums, config, prismaClientPath, logger: internals_1.logger });
+        internals_1.logger.info(`PXL finished!`);
+    }),
+});
+/**
+ * Generates PXL files and flushes them to disk.
+ */
+const generate = ({ models, enums, config, prismaClientPath, logger, }) => __awaiter(void 0, void 0, void 0, function* () {
+    const vfs = new vfs_1.VirtualFS();
+    faker_1.faker.seed(config.randomSeed);
+    // Generate Models
+    for (const model of models) {
+        const meta = (0, meta_1.getModelMetadata)({ model });
+        // Types
+        vfs.write(`/${meta.types.filePath}.ts`, (0, types_generator_1.generateModelTypes)({ model, meta }));
+        // Seed
+        vfs.write(`/${meta.seed.filePath}.ts`, (0, seed_generator_1.generateSeedModel)({ model, itemCount: 5, meta }));
+        // Generate Repositories
+        vfs.write(`/${meta.data.stubFilePath}.ts`, (0, stub_generator_1.generateStub)({ model, meta }));
+        vfs.write(`/${meta.data.repoFilePath}.ts`, (0, repository_generator_1.generateRepository)({ model, meta }));
+        // Routes
+        vfs.write(`/${meta.trpc.routerFilePath}.ts`, (0, route_generator_1.generateRoute)({ model, meta }));
+        // React
+        vfs.copy((0, react_generator_1.generateReactComponentsForModel)({ model, meta }), meta.react.folderPath);
+        logger.log(`✅ ${model.name} generated!`);
+    }
+    // Generate Enums
+    for (const enumerator of enums.values()) {
+        const meta = (0, meta_1.getEnumMetadata)({ enumerator });
+        vfs.write(`/${meta.types.filePath}.ts`, (0, types_generator_2.generateEnumType)({ enumerator, prismaClientPath, meta }));
+        vfs.copy((0, react_generator_2.generateEnumReactComponents)({ enumerator, meta }), meta.react.folderPath);
+    }
+    // Generate Index Files and Services
+    const meta = (0, meta_1.getSchemaMetadata)({ config });
+    vfs.write(`/${meta.data.dataMockModuleFilePath}.ts`, (0, datamockmodule_generator_1.generateDataMockModule)({ models, meta }));
+    vfs.write(`/${meta.data.dataModuleFilePath}.ts`, (0, datamodule_generator_1.generateDataModule)({ models, meta }));
+    vfs.write(`/${meta.data.dataServiceFilePath}.ts`, (0, dataservice_generator_1.generateDataService)({ models, meta }));
+    vfs.write(`/${meta.data.testDataServiceFilePath}.ts`, (0, testdataservice_generator_1.generateTestDataService)({ meta }));
+    vfs.write(`/${meta.data.repositoriesIndexFilePath}.ts`, (0, repositories_generator_1.generateRepositoriesIndex)({ models, meta }));
+    vfs.write(`/${meta.data.stubIndexFilePath}.ts`, (0, stubs_generator_1.generateStubsIndex)({ models, meta }));
+    vfs.write(`/${meta.seed.indexFilePath}.ts`, (0, seed_generator_2.generateSeedIndex)({ models, meta }));
+    vfs.write(`/${meta.trpc.routesFilePath}.ts`, (0, route_generator_1.generateRoutesIndex)({ models, meta }));
+    vfs.write(`/${meta.types.indexFilePath}.ts`, (0, types_generator_3.generateTypesIndex)({ models, enums, meta }));
+    // -------------------------------------------------------------------------
+    // Add disclaimer and format.
+    const prettierConfig = yield prettier.resolveConfig(process.cwd());
+    vfs.transform((path, content) => `${DISCLAIMER}\n${content}`);
+    vfs.format(prettierConfig);
+    const entries = yield vfs.flush(process.cwd(), config.force);
+    const changes = entries.filter((e) => e.status === 'WRITTEN');
+    const skipped = entries.filter((e) => e.status === 'SKIPPED');
+    logger.info(`PXL skipped ${skipped.length} files because checksums didn't match.`);
+    if (changes.length === 0) {
+        logger.info(`PXL generated no files.`);
+        return;
+    }
+    logger.info(`PXL generated the following files:`);
+    for (const file of changes) {
+        logger.info(`+ [generated] ${file.path}`);
+    }
+    logger.info(`PXL finished! 🚀`);
+});
+exports.generate = generate;
+const DISCLAIMER = `/**
+* DO NOT EDIT THIS FILE!  
+*
+* This file was generated by generator.
+* Any manual changes will be overwritten.
+* To modify this file, edit the Prisma schema file and run 
+* \`prisma generate\` or \`pnpm prisma generate\`
+* again!
+* 
+* If you need to modify the structure of this file, please edit the generator
+* at \`packages/generator/\`
+* 
+**/
+`;

package/dist/src/generators/enums/react.generator.d.ts

@@ -0,0 +1,10 @@
+import { EnumMetaData } from '../../lib/meta';
+import { Enum } from '../../lib/schema/schema';
+import { VirtualFS } from '../../lib/vfs';
+/**
+ * Generates React components for a given enumerator.
+ */
+export declare function generateEnumReactComponents({ enumerator, meta }: {
+    enumerator: Enum;
+    meta: EnumMetaData;
+}): VirtualFS;

package/dist/src/generators/enums/react.generator.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateEnumReactComponents = void 0;
+const imports_1 = require("../../lib/imports");
+const vfs_1 = require("../../lib/vfs");
+/**
+ * Generates React components for a given enumerator.
+ */
+function generateEnumReactComponents({ enumerator, meta }) {
+    const vfs = new vfs_1.VirtualFS({
+        'index.ts': `
+			export * from './Select'
+		`,
+    });
+    vfs.write('/Select.tsx', generateEnumSelect({ enumerator, meta }));
+    return vfs;
+}
+exports.generateEnumReactComponents = generateEnumReactComponents;
+/**
+ * Utility function that generates the select component for a given enumerator.
+ */
+function generateEnumSelect({ enumerator, meta }) {
+    const imports = imports_1.ImportsGenerator.from(meta.react.folderPath).addImport({
+        items: [enumerator.typeName],
+        from: meta.types.importPath,
+    });
+    return `
+import { useField } from 'formik'
+import React from 'react'
+
+import { ButtonSwitcher } from '@components/atoms/ButtonSwitcher'
+import { SelectInput, SelectField } from '@components/atoms/SelectInput'
+import { UnionOmit } from '@lib/types'
+
+${imports.generate()}
+
+type Option = {
+	id: ${enumerator.typeName}
+	label: string
+}
+
+const OPTIONS: Option[] = [
+	${enumerator.values.map((v) => `{ id: '${v}', label: '${v}' },`).join('\n')}
+]
+
+// Switcher
+
+export const ${meta.react.switcherInputName} = ({ ...delegated }: UnionOmit<
+  React.ComponentPropsWithoutRef<typeof ButtonSwitcher<${enumerator.typeName}>>, 
+  'options'
+>) => (
+	<ButtonSwitcher options={OPTIONS} {...delegated} />
+)
+
+export const ${meta.react.switcherFieldName} = ({
+	name,
+	...delegated
+}: { name: string } & UnionOmit<
+  React.ComponentPropsWithoutRef<typeof ${meta.react.switcherInputName}>, 
+  'value' | 'onChange'
+>) => {
+	const [field, meta, helpers] = useField<${enumerator.name}>({ name })
+
+	return <${meta.react.switcherInputName} value={field.value} onChange={helpers.setValue} {...delegated} />
+}
+
+// Select
+
+export const ${meta.react.selectInputName} = ({
+  ...delegated
+}: UnionOmit<React.ComponentPropsWithoutRef<typeof SelectInput<Option>>, 'label' | 'options'>) => {
+  return <SelectInput<Option> options={OPTIONS} label={(l) => l.label} {...delegated} />
+}
+
+export const ${meta.react.selectFieldName} = ({
+  ...delegated
+}: UnionOmit<React.ComponentPropsWithoutRef<typeof SelectField<Option>>, 'label' | 'options'>) => {
+  return <SelectField<Option> options={OPTIONS} label={(l) => l.label} {...delegated} />
+}
+`;
+}

package/dist/src/generators/enums/types.generator.d.ts

@@ -0,0 +1,10 @@
+import { EnumMetaData } from '../../lib/meta';
+import { Enum } from '../../lib/schema/schema';
+/**
+ * Generator that generates type definitions for all enumerators.
+ */
+export declare function generateEnumType({ enumerator, meta, prismaClientPath, }: {
+    enumerator: Enum;
+    meta: EnumMetaData;
+    prismaClientPath: string;
+}): string;

package/dist/src/generators/enums/types.generator.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateEnumType = void 0;
+/**
+ * Generator that generates type definitions for all enumerators.
+ */
+function generateEnumType({ enumerator, meta, prismaClientPath, }) {
+    return `
+    import * as Prisma from '${prismaClientPath}'
+
+    export type ${enumerator.typeName} = Prisma.${enumerator.sourceName}
+    export const ${enumerator.typeName} = Prisma.${enumerator.sourceName}
+    export const ${meta.types.membersList}: ${enumerator.typeName}[] = [
+      ${enumerator.values.map((v) => `'${v}'`).join(', ')}
+    ]
+  `;
+}
+exports.generateEnumType = generateEnumType;

package/dist/src/generators/indices/datamockmodule.generator.d.ts

@@ -0,0 +1,9 @@
+import { SchemaMetaData } from '../../lib/meta';
+import { Model } from '../../lib/schema/schema';
+/**
+ * Generates a mocking class
+ */
+export declare function generateDataMockModule({ models, meta }: {
+    models: Model[];
+    meta: SchemaMetaData;
+}): string;

package/dist/src/generators/indices/datamockmodule.generator.js

@@ -0,0 +1,104 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateDataMockModule = void 0;
+const meta_1 = require("../../lib/meta");
+const Types = __importStar(require("../../lib/schema/types"));
+const imports_1 = require("../../lib/imports");
+/**
+ * Generates a mocking class
+ */
+function generateDataMockModule({ models, meta }) {
+    const mm = models.map((model) => ({ model, meta: (0, meta_1.getModelMetadata)({ model }) }));
+    const imports = imports_1.ImportsGenerator.from(meta.data.dataMockModuleFilePath)
+        .addImport({
+        items: [Types.toVariableName('DataModule')],
+        from: meta.data.dataModuleFilePath,
+    })
+        .addImport({
+        items: [Types.toVariableName('DataService')],
+        from: meta.data.dataServiceFilePath,
+    })
+        .addImport({
+        items: [Types.toVariableName('TestDataService')],
+        from: meta.data.testDataServiceFilePath,
+    });
+    for (const { model, meta } of mm) {
+        imports.addImport({ items: [model.typeName], from: meta.types.importPath });
+        imports.addImport({ items: [meta.data.repositoryClassName], from: meta.data.importPath });
+        imports.addImport({ items: [meta.seed.constantName], from: meta.seed.importPath });
+    }
+    const providers = mm
+        .map(({ meta, model }) => `provideMockRepository<
+        ${model.typeName}, 
+        ${model.idField.unbrandedTypeName}, 
+        ${model.typeName}
+      >(${meta.data.repositoryClassName}, ${meta.seed.constantName})`)
+        .join(', ');
+    return `
+import { DynamicModule } from '@nestjs/common'
+import { DbModule } from '@la/db'
+
+import { provideMockRepository } from '../mock.repository'
+
+${imports.generate()}
+
+export class DataMockModule {
+  private static cachedModule: DynamicModule | undefined = undefined
+
+  static isInstantiated(): boolean {
+    return !!DataMockModule.cachedModule
+  }
+  static getInstance(): DataModule {
+    if (!DataMockModule.cachedModule) throw new Error('DataMockModule must be called via .mock first!')
+    return DataMockModule.cachedModule
+  }
+
+  // eslint-disable-next-line @typescript-eslint/require-await, @typescript-eslint/no-unused-vars
+  static async mock(): Promise<DynamicModule> {
+    const providers = [
+      DataService, 
+      TestDataService, 
+      ${providers} 
+    ]
+
+    DataMockModule.cachedModule = {
+      module: DataModule,
+      imports: [DbModule.provideMock()],
+      providers: providers,
+      exports: providers,
+      global: true,
+    }
+
+    return DataMockModule.cachedModule
+  }
+}
+
+export interface MockData {
+  ${mm.map(({ model, meta }) => `${meta.data.mockDataPropertyName}?: ${model.typeName}[]`).join('\n')}
+}
+`;
+}
+exports.generateDataMockModule = generateDataMockModule;

package/dist/src/generators/indices/datamodule.generator.d.ts

@@ -0,0 +1,9 @@
+import { SchemaMetaData } from '../../lib/meta';
+import { Model } from '../../lib/schema/schema';
+/**
+ * Generates a data module class.
+ */
+export declare function generateDataModule({ models, meta }: {
+    models: Model[];
+    meta: SchemaMetaData;
+}): string;

package/dist/src/generators/indices/datamodule.generator.js

@@ -0,0 +1,128 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateDataModule = void 0;
+const meta_1 = require("../../lib/meta");
+const Types = __importStar(require("../../lib/schema/types"));
+const imports_1 = require("../../lib/imports");
+/**
+ * Generates a data module class.
+ */
+function generateDataModule({ models, meta }) {
+    const mm = models.map((model) => ({ model, meta: (0, meta_1.getModelMetadata)({ model }) }));
+    const imports = imports_1.ImportsGenerator.from(meta.data.dataModuleFilePath)
+        .addImport({
+        items: [Types.toVariableName('TestDataService')],
+        from: meta.data.testDataServiceFilePath,
+    })
+        .addImport({
+        items: [Types.toVariableName('DataService')],
+        from: meta.data.dataServiceFilePath,
+    });
+    for (const { meta } of mm) {
+        imports.addImport({
+            items: [meta.data.repositoryClassName],
+            from: meta.data.repoFilePath,
+        });
+    }
+    return `
+import { DynamicModule, Provider, Type } from '@nestjs/common'
+import { DbModule, DbService } from '@la/db'
+
+import { AsyncInit, Repository } from '../repository.type'
+
+${imports.generate()}
+
+const createRepositoryProvider = <T extends AsyncInit>(t: Type<T>, loadData: boolean): Provider => ({
+  inject: [DbService],
+  provide: t,
+  useFactory: async (dbService: DbService): Promise<T> => {
+    const repository = new t(dbService)
+    await dbService.isInitialized(t.name)
+    if (loadData) {
+      await repository.init()
+    }
+    return repository
+  },
+})
+
+export class DataModule {
+  private static cachedModule: DynamicModule | undefined = undefined
+
+  static isInstantiated(): boolean {
+    return !!DataModule.cachedModule
+  }
+
+  static getInstance(): DataModule {
+    if (!DataModule.cachedModule) throw new Error('DataModule must be called via .provide first!')
+    return DataModule.cachedModule
+  }
+
+  static provide({ loadData }: { loadData: boolean }): DynamicModule {
+    if (DataModule.cachedModule) {
+      console.warn('DataModule is already instantiated, skipping...')
+      return DataModule.cachedModule
+    }
+
+    const repositoryProviders: Provider<Repository<any, any>>[] = [
+      ${mm.map(({ meta }) => meta.data.repositoryClassName).join(',\n')}
+    ].map((r) => createRepositoryProvider(r as any, loadData))
+
+    DataModule.cachedModule = {
+      module: DataModule,
+      global: true,
+      imports: [DbModule.provide()],
+      providers: [DataService, ...repositoryProviders],
+      exports: [DataService, ...repositoryProviders],
+    }
+
+    return DataModule.cachedModule
+  }
+
+  static provideE2E(): DynamicModule {
+    if (DataModule.cachedModule) {
+      console.warn('DataModule is already instantiated, skipping...')
+      return DataModule.cachedModule
+    }
+
+    const providers: Provider<Repository<any, any>>[] = [
+      // createRepositoryProvider(TherapeuticAreaRepository, true),
+      TestDataService,
+    ]
+
+    DataModule.cachedModule = {
+      module: DataModule,
+      global: true,
+      imports: [DbModule.provide()],
+      providers: [...providers],
+      exports: providers,
+    }
+
+    return DataModule.cachedModule
+  }
+}
+`;
+}
+exports.generateDataModule = generateDataModule;

package/dist/src/generators/indices/dataservice.generator.d.ts

@@ -0,0 +1,9 @@
+import { SchemaMetaData } from '../../lib/meta';
+import { Model } from '../../lib/schema/schema';
+/**
+ * Generates a generic data service object that may be used on the server to access database.
+ */
+export declare function generateDataService({ models, meta }: {
+    models: Model[];
+    meta: SchemaMetaData;
+}): string;

package/dist/src/generators/indices/dataservice.generator.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateDataService = void 0;
+const meta_1 = require("../../lib/meta");
+const imports_1 = require("../../lib/imports");
+/**
+ * Generates a generic data service object that may be used on the server to access database.
+ */
+function generateDataService({ models, meta }) {
+    const mm = models.map((model) => ({ model, meta: (0, meta_1.getModelMetadata)({ model }) }));
+    const imports = imports_1.ImportsGenerator.from(meta.data.dataServiceFilePath);
+    for (const { meta } of mm) {
+        imports.addImport({
+            items: [meta.data.repositoryClassName],
+            from: meta.data.importPath,
+        });
+    }
+    const constructor = mm
+        .map(({ meta }) => `public ${meta.data.dataServiceName} :${meta.data.repositoryClassName}`)
+        .join(',\n');
+    const initializer = mm.map(({ meta }) => `await this.${meta.data.dataServiceName}.init()`).join(',\n');
+    const excelExports = mm
+        .map(({ meta }) => `${meta.data.excelExportTableName}: mapValues(this.${meta.data.dataServiceName}.getAll()),`)
+        .join('\n');
+    return `
+import { Injectable } from '@nestjs/common'
+import { mapValues } from '@d2i/common'
+
+${imports.generate()}
+
+@Injectable()
+export class DataService {
+  constructor(${constructor}) {}
+
+  public prepareExcelExport() {
+    return {
+      ${excelExports}
+    }
+  }
+
+  public async init(): Promise<void> {
+    ${initializer}
+  }
+}
+`;
+}
+exports.generateDataService = generateDataService;

package/dist/src/generators/indices/repositories.generator.d.ts

@@ -0,0 +1,9 @@
+import { SchemaMetaData } from '../../lib/meta';
+import { Model } from '../../lib/schema/schema';
+/**
+ * Generates an index file that exports all stubs.
+ */
+export declare function generateRepositoriesIndex({ models, meta }: {
+    models: Model[];
+    meta: SchemaMetaData;
+}): string;

package/dist/src/generators/indices/repositories.generator.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateRepositoriesIndex = void 0;
+const exports_1 = require("../../lib/exports");
+const meta_1 = require("../../lib/meta");
+/**
+ * Generates an index file that exports all stubs.
+ */
+function generateRepositoriesIndex({ models, meta }) {
+    const exports = exports_1.ExportsGenerator.from(meta.data.repositoriesIndexFilePath);
+    for (const model of models) {
+        const meta = (0, meta_1.getModelMetadata)({ model });
+        exports.exportEverythingFrom(meta.data.repoFilePath);
+    }
+    return exports.generate();
+}
+exports.generateRepositoriesIndex = generateRepositoriesIndex;

package/dist/src/generators/indices/seed.generator.d.ts

@@ -0,0 +1,9 @@
+import { SchemaMetaData } from '../../lib/meta';
+import { Model } from '../../lib/schema/schema';
+/**
+ * Generates index file for all seed files.
+ */
+export declare function generateSeedIndex({ models, meta }: {
+    models: Model[];
+    meta: SchemaMetaData;
+}): string;