@apso/cli 0.0.5 → 0.0.43

package/dist/lib/templates/rest/controller-rest-spec.eta

@@ -0,0 +1,77 @@
+<%~ includeFile('./header.eta') %>
+
+import { Test, TestingModule } from '@nestjs/testing';
+import {<%= it.entityName %>, <%= it.entityName %>Create} from './dtos/<%= it.entityName%>.dto'
+import {<%= it.ctrlName %>} from "./<%= it.entityName %>.controller";
+import {<%= it.svcName %>} from "./<%= it.entityName %>.service";
+import { CrudRequest } from '@nestjsx/crud';
+
+const baseRequest: CrudRequest = {
+  parsed: {
+    fields: [],
+    paramsFilter: [],
+    search: {},
+    filter: [],
+    or: [],
+    join: [],
+    sort: [],
+    authPersist: undefined,
+    limit: 10,
+    offset: 0,
+    page: 1,
+    cache: undefined,
+  },
+  options: {}
+}
+
+describe('<%= it.ctrlName%>', () => {
+  let controller: <%= it.ctrlName%>;
+  let spyService: <%= it.svcName %>;
+
+  beforeEach(async () => {
+    const ApiServiceProvider = {
+      provide: <%= it.svcName %>,
+      useFactory: () => ({
+        createOne: jest.fn(() => []),
+        getOne: jest.fn(() => { }),
+      })
+    }
+    const module: TestingModule = await Test.createTestingModule({
+      controllers: [<%= it.ctrlName%>],
+      providers: [<%= it.svcName %>, ApiServiceProvider]
+    }).compile();
+
+    controller = module.get<<%= it.ctrlName%>>(<%= it.ctrlName%>);
+    spyService = module.get<<%= it.svcName %>>(<%= it.svcName %>);
+  });
+
+  it('should be defined', () => {
+    expect(controller).toBeDefined();
+  });
+
+  it('should call <%= it.ctrlName%> get method', () => {
+    const req: CrudRequest = { ...baseRequest }
+    expect(controller.get(req)).not.toEqual(null);
+    expect(spyService.getOne).toHaveBeenCalled();
+  });
+
+  it('should call <%= it.ctrlName%> create method', () => {
+    const req: CrudRequest = { ...baseRequest }
+    
+    const dto = new <%= it.entityName %>();
+    controller.create(req, dto);
+    expect(controller.create(req, dto)).not.toEqual(null);
+    expect(spyService.createOne).toHaveBeenCalled();
+  });
+
+  // Add your tests here
+  <% /* getMany(req: CrudRequest): Promise<GetManyDefaultResponse<T> | T[]>;
+    getOne(req: CrudRequest): Promise<T>;
+    createOne(req: CrudRequest, dto: DeepPartial<T>): Promise<T>;
+    createMany(req: CrudRequest, dto: CreateManyDto<DeepPartial<T>>): Promise<T[]>;
+    updateOne(req: CrudRequest, dto: DeepPartial<T>): Promise<T>;
+    recoverOne(req: CrudRequest): Promise<T>;
+    replaceOne(req: CrudRequest, dto: DeepPartial<T>): Promise<T>;
+    deleteOne(req: CrudRequest): Promise<void | T>; */ %>
+});
+  

package/dist/lib/templates/rest/controller-rest.eta

@@ -0,0 +1,171 @@
+<%~ includeFile('./header.eta') %>
+
+import { Controller } from "@nestjs/common";
+import { Crud, CrudController, Override, ParsedRequest, CrudRequest, ParsedBody, CreateManyDto } from '@nestjsx/crud';
+import { ApiTags, ApiResponse, ApiOperation, ApiBody } from '@nestjs/swagger';
+import {<%= it.entityName %>, <%= it.entityName %>Create} from './dtos/<%= it.entityName%>.dto'
+import {<%= it.svcName %>} from './<%= it.entityName %>.service';
+  
+@Crud({
+    model: {
+        type: <%= it.entityName %>
+    },
+    dto: {
+        create: <%= it.entityName %>Create,
+        update: <%= it.entityName %>,
+        replace: <%= it.entityName %>,
+    },
+    query: {
+        /**
+        * commenting out limit and pagination because of an issue with Crud lib: https://github.com/nestjsx/crud/issues/777
+        */
+        // TODO: make limit env driven?
+        limit: 5,
+        alwaysPaginate: true,
+        <% if (it.associations.length) { %>
+            join: {
+                <% it.associations.forEach((assoc) => { %>
+                    <% if (assoc.type === 'OneToMany') { %>
+                    <%= assoc.pluralizedRelationshipName %>: { eager: false },
+                    <% } else if (assoc.type === 'ManyToOne') { %>
+                    <%= assoc.relationshipName %>: { eager: false },
+                    <% } else if (assoc.type === 'ManyToMany') { %>
+                    <%= assoc.pluralizedRelationshipName %>: { eager: false },
+                    <% } else if (assoc.type === 'OneToOne') { %>
+                    <%= assoc.relationshipName %>: { eager: false },
+                    <% } %>
+                <% }) %>
+                <% if (it.nestedAssociations.length) {%>
+                    <% it.nestedAssociations.forEach((assoc) => { %>
+                    "<%= assoc %>": { eager: false },
+                    <% }) %>
+                <% }%>
+            },
+        <% } %>
+     }
+})
+
+@Controller('<%= it.pluralEntityName %>')
+@ApiTags('<%= it.pluralEntityName %>')
+export class <%= it.ctrlName %> implements CrudController<<%= it.entityName %>>{
+    constructor(public service: <%= it.svcName %>) {}
+
+    <% /* https://github.com/nestjsx/crud/wiki/Controllers#routes-override */ %>
+    <% /* Override the core controller methods:
+
+    getManyBase(
+        @ParsedRequest() req: CrudRequest,
+    ): Promise<GetManyDefaultResponse<T> | T[]>;
+
+    getOneBase(
+        @ParsedRequest() req: CrudRequest,
+    ): Promise<T>;
+
+    createOneBase(
+        @ParsedRequest() req: CrudRequest,
+        @ParsedBody() dto: T,
+    ): Promise<T>;
+
+    createManyBase(
+        @ParsedRequest() req: CrudRequest,
+        @ParsedBody() dto: CreateManyDto<T>,
+    ): Promise<T>;
+
+    updateOneBase(
+        @ParsedRequest() req: CrudRequest,
+        @ParsedBody() dto: T,
+    ): Promise<T>;
+
+    replaceOneBase(
+        @ParsedRequest() req: CrudRequest,
+        @ParsedBody() dto: T,
+    ): Promise<T>;
+
+    deleteOneBase(
+        @ParsedRequest() req: CrudRequest,
+    ): Promise<void | T>;
+    */ %>
+
+    get base(): CrudController<<%= it.entityName %>> {
+        return this;
+    }
+
+    @Override('getManyBase')
+    @ApiOperation({ summary: 'Retrieve multiple <%= it.pluralEntityName %>' })
+    getMany(
+        @ParsedRequest() req: CrudRequest,
+    ) {
+        return this.base.getManyBase(req);
+    }
+
+    @Override('getOneBase')
+    @ApiOperation({ summary: 'Retrieve a single <%= it.entityName %>' })
+    get(
+        @ParsedRequest() req: CrudRequest,
+    ) {
+        return this.base.getOneBase(req);
+    }
+
+    @Override('createOneBase')
+    @ApiOperation({ summary: 'Create a single <%= it.entityName %>' })
+    <% /* @ApiResponse({ status: 200, description: 'description goes here', schema: <%= it.entityName %>Create }) */ %>
+    @ApiBody({
+        type: <%= it.entityName %>Create ,
+        description: "The Description for the Post Body. Please look into the DTO. You will see the @ApiOptionalProperty used to define the Schema.",
+        <% /* examples: {
+            a: {
+                summary: "Empty Body",
+                description: "Description for when an empty body is used",
+                value: {} as <%= it.entityName %>Create
+            },
+            b: {
+                summary: "Hello Body",
+                description: "Hello is used as the greeting",
+                value: {greeting: "Hello"} as <%= it.entityName %>Create
+            }
+        } */ %>
+
+    })
+    create(
+        @ParsedRequest() req: CrudRequest,
+        @ParsedBody() dto: <%= it.entityName %>,
+    ) {
+        return this.base.createOneBase(req, dto);
+    }
+
+    @Override('createManyBase')
+    @ApiOperation({ summary: 'Create multiple<%= it.pluralEntityName %>' })
+    createMany(
+        @ParsedRequest() req: CrudRequest,
+        @ParsedBody() dto: CreateManyDto<<%= it.entityName %>>
+    ) {
+        return this.base.createManyBase(req, dto);
+    }
+
+    @Override('updateOneBase')
+    @ApiOperation({ summary: 'Update a single <%= it.entityName %>' })
+    update(
+        @ParsedRequest() req: CrudRequest,
+        @ParsedBody() dto: <%= it.entityName %>,
+    ) {
+        return this.base.updateOneBase(req, dto);
+    }
+
+    @Override('replaceOneBase')
+    @ApiOperation({ summary: 'Replace a single <%= it.entityName %>' })
+    replace(
+        @ParsedRequest() req: CrudRequest,
+        @ParsedBody() dto: <%= it.entityName %>,
+    ) {
+        return this.base.replaceOneBase(req, dto);
+    }
+
+    @Override('deleteOneBase')
+    @ApiOperation({ summary: 'Delete a single <%= it.entityName %>' })
+    delete(
+        @ParsedRequest() req: CrudRequest,
+    ) {
+        return this.base.deleteOneBase(req);
+    }
+}
+  

package/dist/lib/templates/rest/dto-rest.eta

@@ -0,0 +1,48 @@
+import { ApiProperty } from '@nestjs/swagger';
+<%~ includeFile('./header.eta') %>
+
+<% if (it.importEnums) { %>
+import * as enums from '../../enums';
+<% } %>
+
+export class <%= it.name %>Create {
+<% it.columns.forEach((field) => { %>
+    @ApiProperty()
+  <%if (field.dataType.includes("Enum")) {%>
+    <%= field.name %>: enums.<%= field.dataType %>;
+  <%} else if (field.type === 'json' || field.type === 'json-plain') {%>
+    <%= field.name %>: JSON;
+  <%} else if (field.type === 'timestamp' || field.type === 'timestamptz') {%>
+    <%= field.name %>: Date;
+  <%} else {%>
+    <%= field.name %>: <%= field.dataType %>;
+  <% } %>
+<% }) %>
+};
+
+export class <%= it.name %> {
+<% if (it.addDefaultPKProperty) { %>
+    @ApiProperty()
+    id: number;
+<% } %>
+<% it.columns.forEach((field) => { %>
+    @ApiProperty()
+  <%if (field.dataType.includes("Enum")) {%>
+    <%= field.name %>: enums.<%= field.dataType %>;
+  <%} else if (field.type === 'json' || field.type === 'json-plain') {%>
+    <%= field.name %>: JSON;
+  <%} else if (field.type === 'timestamp' || field.type === 'timestamptz') {%>
+    <%= field.name %>: Date;
+  <%} else {%>
+    <%= field.name %>: <%= field.dataType %>;
+  <% } %>
+<% }) %>
+<% if (it.createdAt) { %>
+    @ApiProperty()
+    created_at: Date;
+<% } %>
+<% if (it.updatedAt) { %>
+    @ApiProperty()
+    updated_at: Date;
+<% } %>
+};

package/dist/lib/templates/rest/enums-rest.eta

@@ -0,0 +1,7 @@
+<%~ includeFile('./header.eta') %>
+
+<% it.allEnumsFields.forEach((enumType) => { %>
+export enum <%= enumType.name %> {
+<%~ enumType.values.map((enumValue) => `${enumValue} = '${enumValue}'`).join(', ') %>
+}
+<% }) %>

package/dist/lib/templates/rest/index-module-rest.eta

@@ -0,0 +1,11 @@
+<%~ includeFile('./header.eta') %>
+
+<% it.entities.forEach((entity) => { %>
+import {<%= entity.name %>Module} from './<%= entity.name %>/<%= entity.name %>.module'
+<%}) %>
+
+export default [
+<% it.entities.forEach((entity) => { %>
+<%= entity.name %>Module,
+<%}) %>
+]

package/dist/lib/templates/rest/module-rest.eta

@@ -0,0 +1,16 @@
+<%~ includeFile('./header.eta') %>
+
+import { Module } from "@nestjs/common";
+import {<%= it.entityName %>} from './<%= it.entityName%>.entity'
+import { TypeOrmModule } from "@nestjs/typeorm";
+import {<%= it.svcName %>} from "./<%= it.entityName %>.service";
+import {<%= it.ctrlName %>} from "./<%= it.entityName %>.controller";
+
+@Module({
+  imports: [TypeOrmModule.forFeature([<%= it.entityName %>])],
+  providers: [<%= it.svcName %>],
+  exports: [<%= it.svcName %>],
+  controllers: [<%= it.ctrlName %>],
+})
+export class <%= it.modName %> {}
+  

package/dist/lib/templates/rest/ormconfig.eta

@@ -0,0 +1,9 @@
+<% it.entities.forEach((entity) => { %>
+import {<%= entity.name %>} from './autogen/<%= entity.name %>/<%= entity.name %>.entity'
+<%}) %>
+
+const entities = [
+<% it.entities.forEach((entity) => { %>
+<%= entity.name %>,
+<%}) %>
+]

package/dist/lib/templates/rest/service-rest.eta

@@ -0,0 +1,25 @@
+<%~ includeFile('./header.eta') %>
+
+import { Injectable } from "@nestjs/common";
+import { InjectRepository } from "@nestjs/typeorm";
+import { TypeOrmCrudService } from "@nestjsx/crud-typeorm";
+import { QueryOptions } from '@nestjsx/crud';
+import { ParsedRequestParams } from '@nestjsx/crud-request';
+
+import {<%= it.entityName %>} from './<%= it.entityName%>.entity'
+
+@Injectable()
+export class <%= it.svcName %> extends TypeOrmCrudService<<%= it.entityName %>> {
+  constructor(@InjectRepository(<%= it.entityName %>) repo) {
+    super(repo);
+  }
+
+      /**
+      * 
+      * Solves https://github.com/nestjsx/crud/issues/777
+      */
+      getSelect(query: ParsedRequestParams, options: QueryOptions) {
+        return [...new Set(super.getSelect(query, options))]
+      }
+}
+  

package/dist/lib/types/constraints.d.ts

@@ -0,0 +1,4 @@
+export interface Unique {
+    fields: string[];
+    name?: string;
+}

package/dist/lib/types/constraints.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/lib/types/entity.d.ts

@@ -0,0 +1,13 @@
+import { Unique } from "./constraints";
+import { Field } from "./field";
+import { Index } from "./indices";
+import { Association } from "./relationship";
+export interface Entity {
+    name: string;
+    created_at?: boolean;
+    updated_at?: boolean;
+    fields?: Field[];
+    indexes?: Index[];
+    uniques?: Unique[];
+    associations?: Association[];
+}

package/dist/lib/types/entity.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/lib/types/field.d.ts

@@ -0,0 +1,16 @@
+export type FieldType = "text" | "boolean" | "array" | "enum" | "integer" | "float" | "date" | "json" | "json-plain";
+export interface Field {
+    name: string;
+    type: FieldType;
+    values?: string[];
+    nullable?: boolean;
+    index?: boolean;
+    primary?: boolean;
+    unique?: boolean;
+    default?: string | null;
+    length?: number;
+    is_email?: boolean;
+}
+export interface ComputedField extends Field {
+    dataType: string;
+}

package/dist/lib/types/field.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/lib/types/index.d.ts

@@ -0,0 +1,5 @@
+export { Entity } from "./entity";
+export { FieldType, Field, ComputedField } from "./field";
+export { Index } from "./indices";
+export { JSONValue } from "./json";
+export { RelationshipType, Association, ApsorcRelationship, Relationship, RelationshipForTemplate, RelationshipMap, } from "./relationship";

package/dist/lib/types/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/lib/types/indices.d.ts

@@ -0,0 +1,4 @@
+export interface Index {
+    fields: string[];
+    unique?: boolean;
+}

package/dist/lib/types/indices.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/lib/types/json.d.ts

@@ -0,0 +1,3 @@
+export type JSONValue = string | number | boolean | undefined | {
+    [x: string]: JSONValue;
+} | Array<JSONValue>;

package/dist/lib/types/json.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/lib/types/relationship.d.ts

@@ -0,0 +1,43 @@
+export type RelationshipType = "OneToMany" | "ManyToOne" | "ManyToMany" | "OneToOne";
+export interface ApsorcRelationship {
+    from: string;
+    to: string;
+    type: RelationshipType;
+    to_name?: string;
+    nullable?: boolean;
+    bi_directional?: boolean;
+    cascadeDelete?: boolean;
+    index?: boolean;
+}
+export interface Relationship {
+    name: string;
+    type: RelationshipType;
+    referenceName?: string | null;
+    nullable?: boolean;
+    join?: boolean;
+    biDirectional?: boolean;
+    cascadeDelete?: boolean;
+    index?: boolean;
+}
+export interface RelationshipForTemplate extends Relationship {
+    relationshipName: string;
+    pluralizedRelationshipName: string;
+    pluralizedName: string;
+    camelCasedName: string;
+    camelCasedId: string;
+    entityName: string;
+    joinTable: boolean;
+    biDirectional: boolean;
+}
+export type RelationshipMap = {
+    [key: string]: Relationship[];
+};
+export interface Association {
+    name: string;
+    type: RelationshipType;
+    join_table?: boolean;
+    reference_name?: string;
+    nested?: boolean;
+    nullable?: boolean;
+    index?: boolean;
+}

package/dist/lib/types/relationship.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/lib/utils/casing.d.ts

@@ -0,0 +1,2 @@
+export declare const camelCase: (str: string, firstUpper?: boolean) => string;
+export declare const snakeCase: (str: string) => string;

package/dist/lib/utils/casing.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.snakeCase = exports.camelCase = void 0;
+const camelCase = (str, firstUpper) => {
+    const firstLetter = firstUpper ? str[0].toUpperCase() : str[0].toLowerCase();
+    const restOfLetters = str
+        .slice(1)
+        .replace(/_[A-Za-z]/g, (underLetter) => underLetter[1].toUpperCase());
+    return `${firstLetter}${restOfLetters}`;
+};
+exports.camelCase = camelCase;
+const snakeCase = (str) => str[0].toLowerCase() +
+    str
+        .slice(1, str.length)
+        .replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
+exports.snakeCase = snakeCase;

package/dist/lib/utils/field.d.ts

@@ -0,0 +1,6 @@
+import { FieldType, Field, ComputedField, Entity } from "../types";
+export declare const getJsTypeFromFieldType: (type: FieldType) => string;
+export declare const getDefaultValueForField: (field: Field) => string | null;
+export declare const getFieldForTemplate: (fields: Field[], entityName: string) => ComputedField[];
+export declare const fieldToEnumType: (fieldName: string, entityName: string) => string;
+export declare const typeExistsInEntity: (entity: Entity, type: string) => number;

package/dist/lib/utils/field.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.typeExistsInEntity = exports.fieldToEnumType = exports.getFieldForTemplate = exports.getDefaultValueForField = exports.getJsTypeFromFieldType = void 0;
+const casing_1 = require("./casing");
+const getJsTypeFromFieldType = (type) => {
+    switch (type) {
+        case "array":
+            return "string[]";
+        case "boolean":
+            return "boolean";
+        case "integer":
+            return "number";
+        case "float":
+            return "number";
+        case "text":
+        case "enum":
+        default:
+            return "string";
+    }
+};
+exports.getJsTypeFromFieldType = getJsTypeFromFieldType;
+const getDefaultValueForField = (field) => {
+    var _a, _b;
+    switch (field.type) {
+        case "enum":
+            if (field.default === null) {
+                return null;
+            }
+            if (typeof field.default !== "undefined") {
+                if (!((_a = field.values) === null || _a === void 0 ? void 0 : _a.includes(field.default))) {
+                    throw new Error(`${field.name}: Invalid default value '${field.default}' (Valid options are: '${(_b = field.values) === null || _b === void 0 ? void 0 : _b.join("', '")}')`);
+                }
+                return field.default;
+            }
+            if (typeof field.values !== "undefined") {
+                return field.values[0];
+            }
+            return null;
+        case "boolean":
+            if (typeof field.default !== "undefined") {
+                return field.default;
+            }
+            return "false";
+        default:
+            if (typeof field.default !== "undefined") {
+                return field.default;
+            }
+            return null;
+    }
+};
+exports.getDefaultValueForField = getDefaultValueForField;
+const getFieldForTemplate = (fields, entityName) => fields.map((field) => ({
+    ...field,
+    default: (0, exports.getDefaultValueForField)(field),
+    dataType: field.type === "enum"
+        ? (0, exports.fieldToEnumType)(field.name, entityName)
+        : (0, exports.getJsTypeFromFieldType)(field.type),
+}));
+exports.getFieldForTemplate = getFieldForTemplate;
+const fieldToEnumType = (fieldName, entityName) => `${(0, casing_1.camelCase)(entityName, true)}${(0, casing_1.camelCase)(fieldName, true)}Enum`;
+exports.fieldToEnumType = fieldToEnumType;
+const typeExistsInEntity = (entity, type) => (entity === null || entity === void 0 ? void 0 : entity.fields)
+    ? entity === null || entity === void 0 ? void 0 : entity.fields.findIndex((field) => field.type === type)
+    : -1;
+exports.typeExistsInEntity = typeExistsInEntity;

package/dist/lib/utils/file-system.d.ts

@@ -0,0 +1,2 @@
+export declare const createFile: (file: string, content: string) => void;
+export declare const createDirectoryContents: (templatePath: string, newProjectPath: string, apiType: string) => void;

package/dist/lib/utils/file-system.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDirectoryContents = exports.createFile = void 0;
+const tslib_1 = require("tslib");
+const path = tslib_1.__importStar(require("path"));
+const fs = tslib_1.__importStar(require("fs"));
+const createDir = (dirname) => {
+    if (!fs.existsSync(dirname)) {
+        fs.mkdirSync(dirname, { recursive: true });
+    }
+};
+const createFile = (file, content) => {
+    const dirname = path.dirname(file);
+    createDir(dirname);
+    fs.writeFileSync(file, content);
+};
+exports.createFile = createFile;
+const createDirectoryContents = (templatePath, newProjectPath, apiType) => {
+    const filesToCreate = fs.readdirSync(templatePath);
+    const CURR_DIR = process.cwd();
+    filesToCreate.forEach((file) => {
+        const origFilePath = `${templatePath}/${file}`;
+        // get stats about the current file
+        const stats = fs.statSync(origFilePath);
+        if (stats.isFile()) {
+            writeFile(file, origFilePath, `${CURR_DIR}/${newProjectPath}`, stats.mode, apiType);
+        }
+        else if (stats.isDirectory()) {
+            fs.mkdirSync(`${CURR_DIR}/${newProjectPath}/${file}`);
+            // recursive call
+            (0, exports.createDirectoryContents)(`${templatePath}/${file}`, `${newProjectPath}/${file}`, apiType);
+        }
+    });
+};
+exports.createDirectoryContents = createDirectoryContents;
+/* eslint-disable max-params */
+const writeFile = (fileName, origFilePath, writePath, mode, apiType) => {
+    const contents = fs.readFileSync(origFilePath, "utf8");
+    if (fileName.startsWith("app.module") && fileName.includes(apiType)) {
+        fileName = "app.module.ts";
+        const fileWritePath = `${writePath}/${fileName}`;
+        fs.writeFileSync(fileWritePath, contents, "utf8");
+        fs.chmodSync(fileWritePath, mode);
+    }
+    else if (!fileName.startsWith("app.module")) {
+        if (fileName === ".npmignore")
+            fileName = ".gitignore";
+        const fileWritePath = `${writePath}/${fileName}`;
+        fs.writeFileSync(fileWritePath, contents, "utf8");
+        fs.chmodSync(fileWritePath, mode);
+    }
+};

package/dist/lib/utils/relationships/index.d.ts

@@ -0,0 +1,2 @@
+export { parseRelationships, getRelationshipsForImport, getRelationshipForTemplate, getNestedRelationships, getRelationshipIdField, } from "./parse";
+export { parseV1Relationships } from "./parse-v1";