@postxl/generator 0.73.5 → 0.74.0

package/dist/generator.js

@@ -421,20 +421,31 @@ function generate(_a) {
         }
         // NOTE: Lastly we generate the log of the changes.
         const log = lock_1.ConsoleUtils.getFilesChangelog(results.map((result) => {
-            if (result.status === 'write') {
-                if (result.prevDisk === undefined) {
-                    return { path: result.path, status: 'new' };
-                }
-                if (result.disk === undefined) {
-                    return { path: result.path, status: 'deleted' };
-                }
-                if (runtime_1.BufferUtils.equals(result.prevDisk.content, result.disk.content) &&
-                    result.prevDisk.mode === result.disk.mode) {
-                    return { path: result.path, status: 'unchanged' };
+            switch (result.status) {
+                case 'write': {
+                    if (result.prevDisk === undefined) {
+                        return { path: result.path, status: 'new' };
+                    }
+                    if (result.disk === undefined) {
+                        return { path: result.path, status: 'deleted' };
+                    }
+                    if (runtime_1.BufferUtils.equals(result.prevDisk.content, result.disk.content) &&
+                        result.prevDisk.mode === result.disk.mode) {
+                        return { path: result.path, status: 'unchanged' };
+                    }
+                    return { path: result.path, status: 'changed' };
                 }
-                return { path: result.path, status: 'changed' };
+                case 'skip':
+                    if (result.prevDisk &&
+                        result.disk &&
+                        runtime_1.BufferUtils.equals(result.prevDisk.content, result.disk.content) &&
+                        result.prevDisk.mode === result.disk.mode) {
+                        return { path: result.path, status: 'unchanged' };
+                    }
+                    return { path: result.path, status: 'skipped' };
+                default:
+                    throw new types_2.ExhaustiveSwitchCheck(result);
             }
-            return { path: result.path, status: 'skipped' };
         }));
         console.info(log);
         const perfEnd = performance.now();

package/dist/generators/indices/export/class.generator.js

@@ -39,12 +39,12 @@ function generateExporterClass({ models, meta }) {
             }
             const linkedModelMeta = (0, meta_1.getModelMetadata)({ model: field.relationToModel });
             if (field.isRequired) {
-                linkedItems.push(`await this.${linkedModelMeta.export.exportAddFunctionName}({id: item.${field.name}, includeChildren: false})`);
+                linkedItems.push(`await this.${linkedModelMeta.export.exportAddFunctionName}({id: item.${field.name}, includeChildren: false, user})`);
             }
             else {
                 linkedItems.push(`
           if (item.${field.name}) { 
-            await this.${linkedModelMeta.export.exportAddFunctionName}({id: item.${field.name}, includeChildren: false})
+            await this.${linkedModelMeta.export.exportAddFunctionName}({id: item.${field.name}, includeChildren: false, user})
           }`);
             }
         }
@@ -55,7 +55,7 @@ function generateExporterClass({ models, meta }) {
             childItemCalls.push(`
         // Add all ${linkedModelMeta.userFriendlyNamePlural} that are related to the ${modelMeta.userFriendlyName} via ${referencingField.name}
         for (const ${referencingField.name} of await this.viewService.${linkedModelMeta.view.serviceVariableName}.data.${linkedFieldMeta.getByForeignKeyIdsMethodFnName}(id)) {
-          await this.${linkedModelMeta.export.exportAddFunctionName}({id: ${referencingField.name}, includeChildren})
+          await this.${linkedModelMeta.export.exportAddFunctionName}({id: ${referencingField.name}, includeChildren, user})
         }
         `);
         }
@@ -65,7 +65,7 @@ function generateExporterClass({ models, meta }) {
             ${childItemCalls.join('\n')}
           }`
             : '';
-        const signature = `{id, includeChildren = true}: {id: ${model.brandedIdType}, includeChildren?: boolean}`;
+        const signature = `{id, includeChildren = true, user}: {id: ${model.brandedIdType}, includeChildren?: boolean, user: User}`;
         addFunctions.push(`
         /**
          * Adds a ${modelMeta.userFriendlyName} and all related (and nested) dependencies to the export.
@@ -74,7 +74,7 @@ function generateExporterClass({ models, meta }) {
           if (this.${modelMeta.internalPluralName}.has(id)) {
             return
           }
-          const item = await this.viewService.${modelMeta.view.serviceVariableName}.get(id)
+          const item = await this.viewService.${modelMeta.view.serviceVariableName}.get({ id, user })
           if (!item) {
             this.logger.error(\`Cannot find ${modelMeta.userFriendlyName} \${id}\`)
             return
@@ -86,7 +86,7 @@ function generateExporterClass({ models, meta }) {
           ${childItems}
         }
       `);
-        addAllCalls.push(`this.${modelMeta.internalPluralName} = await this.viewService.${modelMeta.view.serviceVariableName}.getAll()`);
+        addAllCalls.push(`this.${modelMeta.internalPluralName} = await this.viewService.${modelMeta.view.serviceVariableName}.getAll(user)`);
     }
     return /* ts */ `
 // For consistency, we include \`{ includeChildren = true }\` in the signature of every add function.
@@ -126,7 +126,7 @@ export class ${meta.export.exporterClass.name} {
   /**
    * Exports all data.
    */
-  public async exportAll(): Promise<${meta.export.encoder.encodedExcelDataTypeName}> {
+  public async exportAll(user: User): Promise<${meta.export.encoder.encodedExcelDataTypeName}> {
     ${addAllCalls.join('\n')}
 
     return this.exportData()

package/dist/generators/models/route.generator.js

@@ -35,10 +35,14 @@ export const ${meta.trpc.routerName} = router({
   ${defaultField ? defaultValueMethod : ''}
   
   get: procedure
+    .use(authMiddleware)
     .input(z.${idField.unbrandedTypeName}().transform(${meta.types.toBrandedIdTypeFnName}))
-    .query(({ input, ctx }) => ctx.view.${meta.data.dataServiceName}.get(input)),
-  getMap: procedure.query(({ ctx }) => ctx.view.${meta.data.dataServiceName}.getAll()),
+    .query(({ input, ctx }) => ctx.view.${meta.data.dataServiceName}.get({ id: input, user: ctx.user})),
+  getMap: procedure
+  .use(authMiddleware)
+  .query(({ ctx }) => ctx.view.${meta.data.dataServiceName}.getAll(ctx.user)),
   getList: procedure
+    .use(authMiddleware)
     .input(z.object({
       cursor: ${meta.view.cursorDecoder}.optional(),
       sort: z.object({
@@ -60,7 +64,7 @@ export const ${meta.trpc.routerName} = router({
       .optional(),
     }))
     .query(({ input, ctx }) => {
-      return ctx.view.${meta.data.dataServiceName}.getList(input)
+      return ctx.view.${meta.data.dataServiceName}.getList({...input, user: ctx.user })
     }),
 
     create: procedure

package/dist/generators/models/update/service.generator.js

@@ -22,7 +22,7 @@ function generateModelBusinessLogicUpdate({ model, meta }) {
     const { view, update, types, data } = meta;
     const imports = imports_1.ImportsGenerator.from(meta.update.serviceClassLocation.path).addImports({
         [data.repository.location.import]: data.repository.className,
-        [types.importPath]: [model.brandedIdType, types.typeName, types.toBrandedIdTypeFnName],
+        [types.importPath]: [model.brandedIdType, types.typeName, types.toBrandedIdTypeFnName, (0, types_1.toTypeName)('User')],
         [view.serviceLocation.import]: [view.serviceClassName],
         [schemaMeta.actions.execution.interfaceLocation.import]: [schemaMeta.actions.execution.interface],
         [schemaMeta.actions.dispatcher.definitionLocation.import]: [schemaMeta.actions.dispatcher.definition],
@@ -47,6 +47,8 @@ function generateModelBusinessLogicUpdate({ model, meta }) {
 
     ${imports.generate()}
 
+    import { TRPCError } from '@trpc/server'
+
     export type Scope = "${meta.actions.actionScopeConstType}"
 
     export type Actions = {
@@ -136,6 +138,15 @@ function generateModelBusinessLogicUpdate({ model, meta }) {
         data: CreatePayload; 
         execution: ${schemaMeta.actions.execution.interface}
       }): Promise<${types.typeName}> {
+        // NOTE: User from execution.user should be authorized to create this item.
+        // eslint-disable-next-line no-constant-condition
+        if (false) {
+          throw new TRPCError({
+            code: 'UNAUTHORIZED',
+            message: \`You are not authorized to create a ${meta.userFriendlyName}\`,
+          })
+        }
+
         return this.data.create({ item: data, execution })
       }
 
@@ -144,6 +155,9 @@ function generateModelBusinessLogicUpdate({ model, meta }) {
         data: UpdatePayload; 
         execution: ${schemaMeta.actions.execution.interface}
       }): Promise<${types.typeName}> {
+        // NOTE: We need to make sure that the user is authorized to access the item
+        await this.authorize(data.id, execution.user)
+
         return this.data.update({ item: data, execution })
       }
 
@@ -152,6 +166,18 @@ function generateModelBusinessLogicUpdate({ model, meta }) {
         data: UpsertPayload;
         execution: ${schemaMeta.actions.execution.interface}
       }): Promise<${types.typeName}> {
+        if ('id' in data) {
+          await this.authorize(data.id, execution.user)
+        } else {
+          // eslint-disable-next-line no-constant-condition
+          if (false) {
+            throw new TRPCError({
+              code: 'UNAUTHORIZED',
+              message: \`You are not authorized to create a ${meta.userFriendlyName}\`,
+            })
+          }
+        }
+
         return this.data.upsert({ item: data, execution })
       }
 
@@ -160,10 +186,34 @@ function generateModelBusinessLogicUpdate({ model, meta }) {
         data: ${model.brandedIdType}; 
         execution: ${schemaMeta.actions.execution.interface}
       }): Promise<${model.brandedIdType}> {
+        // NOTE: We need to make sure that the user is authorized to access the item
+        await this.authorize(data, execution.user)
+
         return this.data.delete({ id: data, execution })
       }
 
       ${cloneFn}
+
+      /**
+      * Authorizes access to ${meta.userFriendlyName}.
+      */
+      public async authorize(id: ${model.brandedIdType}, user: User): Promise<void> {
+        // NOTE: Root user is always authorized.
+        if (this.viewService.users.data.rootUser.id === user.id) {
+          return
+        }
+        const item = await this.data.get(id)
+        if (!item) {
+          throw new Error(\`${meta.userFriendlyName} with id \${id} not found\`)
+        }
+        // eslint-disable-next-line no-constant-condition
+        if (false) {
+          throw new TRPCError({
+            code: 'UNAUTHORIZED',
+            message: \`You are not authorized to access ${meta.userFriendlyName} with id \${id}\`,
+          })
+        }
+      }
     }
  `;
 }

package/dist/generators/models/view/service.generator.js

@@ -15,7 +15,11 @@ function generateModelBusinessLogicView({ model, meta }) {
     const imports = imports_1.ImportsGenerator.from(meta.view.serviceLocation.path);
     imports.addImports({
         [meta.data.repository.location.import]: meta.data.repository.className,
-        [meta.types.importPath]: [(0, types_1.toAnnotatedTypeName)(model.brandedIdType), (0, types_1.toAnnotatedTypeName)(meta.types.typeName)],
+        [meta.types.importPath]: [
+            (0, types_1.toAnnotatedTypeName)(model.brandedIdType),
+            (0, types_1.toAnnotatedTypeName)(meta.types.typeName),
+            (0, types_1.toAnnotatedTypeName)((0, types_1.toTypeName)('User')),
+        ],
         [schemaMeta.view.serviceLocation.path]: schemaMeta.view.serviceClassName,
     });
     const compareFnBlock = (0, ast_1.createSwitchStatement)({
@@ -84,6 +88,9 @@ import { Inject, Injectable, forwardRef } from '@nestjs/common'
 
 ${imports.generate()}
 
+import { TRPCError } from '@trpc/server'
+
+
 /**
  * Cursor decoder.
  */
@@ -123,15 +130,34 @@ export class ${meta.view.serviceClassName} {
    * Returns the raw ${meta.userFriendlyName} with the given id or null if it does not exist.
    * Raw: The ${meta.userFriendlyName} only contains linked Ids, not the linked items themselves.
    */
-  public async get(id: ${model.brandedIdType}): Promise<${meta.types.typeName} | null> {
-    return this.data.get(id)
+  public async get({ id, user }: { id: ${model.brandedIdType}, user: User }): Promise<${meta.types.typeName} | null> {
+    const item = await this.data.get(id)
+    if (!item) {
+      return null
+    }
+
+    // NOTE: Authorizing user to access the item.
+    await this.authorize({ item, user })
+
+    return item
   }
 
   /**
    * Returns a map of all ${meta.userFriendlyNamePlural}.
    */
-  public async getAll(): Promise<Map<${meta.types.brandedIdType}, ${model.typeName}>> {
-    return this.data.getAll()
+  public async getAll(user: User): Promise<Map<${meta.types.brandedIdType}, ${model.typeName}>> {
+        const result = await this.data.getAll()
+
+        // NOTE: Removing non-authorized items from the result.
+        for (const [key, value] of result.entries()) {
+          try {
+            await this.authorize({ item: value, user })
+          } catch (e) {
+            result.delete(key)
+          }
+        }
+    
+        return result
   }
 
   /**
@@ -141,24 +167,51 @@ export class ${meta.view.serviceClassName} {
     filter,
     sort,
     cursor,
+    user,
   }: {
     filter?: { field: keyof ${model.typeName}; operator: FilterOperator; value: string | number }
     sort?: { field: keyof ${model.typeName}; ascending: boolean }
     cursor?: Cursor
-  }) {
-    const items = await this.data.getAllAsArray()
+    user: User,
+  },
+) {
+    const items = await this.data.getAll()
+
+    // NOTE: Removing non-authorized items from the result.
+    for (const [key, value] of items.entries()) {
+      try {
+        await this.authorize({ item: value, user })
+      } catch (e) {
+        items.delete(key)
+      }
+    }
+    const authorized = [...items.values()]
+
     const filtered = !filter
-      ? items
-      : items.filter((item) => filterFn(item, filter.field, filter.operator, filter.value))
+      ? authorized
+      : authorized.filter((item) => filterFn(item, filter.field, filter.operator, filter.value))
 
     const filteredAndSorted = !sort
       ? filtered
       : filtered.sort((a, b) => (sort.ascending ? compare(a, b, sort.field) : -compare(a, b, sort.field)))
 
     const paginated = !cursor ? filteredAndSorted : filteredAndSorted.slice(cursor.startRow, cursor.endRow)
-    return { rows: paginated, count: items.length }
+    return { rows: paginated, count: authorized.length }
   }
 
+  /**
+  * Authorizes access to ${meta.userFriendlyName}.
+  */
+  // eslint-disable-next-line @typescript-eslint/require-await
+  public async authorize({ item, user}: { item: ${model.typeName}, user: User }): Promise<void> {
+    // eslint-disable-next-line no-constant-condition
+    if (false) {
+      throw new TRPCError({
+        code: 'UNAUTHORIZED',
+        message: \`You are not authorized to access ${meta.userFriendlyName} with id \${item.id}\`,
+      })
+    }
+  }
 }
 
 // Utility Functions

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

@@ -18,6 +18,10 @@ export declare const toPascalCase: (str: string) => string;
  * Returns a pluralized version of the given string based on the count.
  */
 export declare const pluralize: (s: string, count?: number) => string;
+/**
+ * Returns true if the given string is already pluralized.
+ */
+export declare const isPlural: (s: string) => boolean;
 /**
  * Converts each line of a string to a commented line
  */

package/dist/lib/utils/string.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.conjugateNames = exports.commentLines = exports.pluralize = exports.toPascalCase = exports.toCamelCase = exports.capitalize = exports.uncapitalize = void 0;
+exports.conjugateNames = exports.commentLines = exports.isPlural = exports.pluralize = exports.toPascalCase = exports.toCamelCase = exports.capitalize = exports.uncapitalize = void 0;
 /**
  * Returns the same string with a lowercase first letter.
  */
@@ -88,6 +88,9 @@ const pluralize = (s, count = 2) => {
             return s.slice(0, -singular.length + 1) + plural.slice(1);
         }
     }
+    if (lower.endsWith('ss')) {
+        return s.slice(0, -2) + 'sses';
+    }
     if (s.endsWith('y') &&
         !s.endsWith('ay') &&
         !s.endsWith('ey') &&
@@ -102,6 +105,14 @@ const pluralize = (s, count = 2) => {
     return s + 's';
 };
 exports.pluralize = pluralize;
+/**
+ * Returns true if the given string is already pluralized.
+ */
+const isPlural = (s) => {
+    const plural = (0, exports.pluralize)(s);
+    return plural === s;
+};
+exports.isPlural = isPlural;
 /**
  * Converts each line of a string to a commented line
  */

package/dist/prisma/parse.js

@@ -34,6 +34,7 @@ const attributes_1 = require("./attributes");
  */
 function parsePrismaSchema({ datamodel: { enums: enumsRaw, models: modelsRaw }, config, }) {
     ensurePXLSystemModelsExist(modelsRaw);
+    ensureConsistency({ models: modelsRaw, enums: enumsRaw });
     // NOTE: We preprocess models and enums so that we can populate relationships.
     const models = modelsRaw.map((dmmfModel) => parseModelCore({ dmmfModel, config }));
     const enums = enumsRaw.map((dmmfEnum) => parseEnum({ dmmfEnum, config }));
@@ -72,6 +73,56 @@ function ensurePXLSystemModelsExist(models) {
         }
     }
 }
+/**
+ * Validates:
+ * - That there are no duplicate model names
+ * - That model names are singular
+ * - That model attributes are valid
+ * - That field attributes are valid
+ * - That enum attributes are valid
+ */
+function ensureConsistency({ models, enums }) {
+    const errors = [];
+    const modelNames = models.map((m) => m.name);
+    const duplicateModelName = modelNames.find((name, i) => modelNames.indexOf(name) !== i);
+    if (duplicateModelName) {
+        errors.push(`Model ${duplicateModelName} is defined more than once.`);
+    }
+    for (const model of models) {
+        if ((0, string_1.isPlural)(model.name)) {
+            errors.push(`Model ${(0, logger_1.highlight)(model.name)} is plural. Please use singular names for models.`);
+        }
+        try {
+            (0, attributes_1.getModelAttributes)(model);
+        }
+        catch (e) {
+            errors.push(`Model ${(0, logger_1.highlight)(model.name)} has invalid model attributes: ${(0, error_1.extractError)(e)}`);
+        }
+    }
+    for (const model of models) {
+        for (const field of model.fields) {
+            try {
+                (0, attributes_1.getFieldAttributes)(field);
+            }
+            catch (e) {
+                errors.push(`Model ${(0, logger_1.highlight)(model.name)} has invalid attributes for field ${(0, logger_1.highlight)(field.name)}: 
+            ${(0, error_1.extractError)(e)}`);
+            }
+        }
+    }
+    for (const enumDef of enums) {
+        try {
+            (0, attributes_1.getEnumAttributes)(enumDef);
+        }
+        catch (e) {
+            errors.push(`Enum ${(0, logger_1.highlight)(enumDef.name)} has invalid attributes: 
+        ${(0, error_1.extractError)(e)}`);
+        }
+    }
+    if (errors.length > 0) {
+        (0, error_1.throwError)(`${errors.length} ${(0, string_1.pluralize)('issue', errors.length)} detected in schema:\n   * ${errors.join('\n   * ')}`);
+    }
+}
 function isModelNotIgnored(model) {
     return model !== undefined && !model.attributes.ignore;
 }
@@ -79,6 +130,9 @@ function isModelNotIgnored(model) {
  * Parses the core properties of a model without fields.
  */
 function parseModelCore({ dmmfModel, config, }) {
+    if ((0, string_1.isPlural)(dmmfModel.name)) {
+        (0, error_1.throwError)(`Model ${dmmfModel.name} is plural. Please use singular names for models.`);
+    }
     const attributes = (0, attributes_1.getModelAttributes)(dmmfModel);
     return {
         name: Types.toModelName((0, string_1.toPascalCase)(dmmfModel.name)),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@postxl/generator",
-  "version": "0.73.5",
+  "version": "0.74.0",
   "main": "./dist/generator.js",
   "typings": "./dist/generator.d.ts",
   "bin": {