@appweaver/cli 1.3.1 → 1.4.0

package/generate/generate-schema.js

@@ -8,6 +8,22 @@ const node_path_1 = __importDefault(require("node:path"));
 const promises_1 = __importDefault(require("node:fs/promises"));
 const common_1 = require("@appweaver/common");
 const utils_1 = require("../utils");
+const INDEX_SORT_PREFIXES = {
+    '-': 'Desc',
+    '+': 'Asc'
+};
+const UUID_LENGTH = 36;
+const CUID_LENGTHS = {
+    '': 25,
+    '2': 24
+};
+const NANOID_LENGTH = 21;
+const UUID_NATIVE_TYPES = {
+    [common_1.DatabaseType.PostgresSQL]: '@db.Uuid',
+    [common_1.DatabaseType.SQLServer]: '@db.UniqueIdentifier',
+    [common_1.DatabaseType.MySQL]: `@db.Char(${UUID_LENGTH})`
+};
+const defaultIdColumn = () => ({ type: 'Int' });
 /**
  * Generates a Prisma schema file based on the provided resource models and saves it to the specified file path.
  *
@@ -58,6 +74,12 @@ async function generateSchema(models, schemaPath, clientPath, quiet = false) {
                 break;
             }
         }
+        // A foreign key column has to match the primary key column it references,
+        // native type included, or the database rejects the constraint
+        const idColumnOf = (modelName) => {
+            const id = models[(0, common_1.capitalize)(modelName)]?.config?.id;
+            return { type: prismaIdType(id), nativeType: idNativeType(id) };
+        };
         // Create Prisma models and enums from resource model config
         for (const [name, schema] of Object.entries(models)) {
             if (schema.config.generateSchema === false) {
@@ -66,8 +88,8 @@ async function generateSchema(models, schemaPath, clientPath, quiet = false) {
             prismaModels[name] = {
                 id: createIdSchema(schema.config.id),
                 scalars: createScalarsSchema(name, schema.config.scalars),
-                relations: createRelationsSchema(name, schema.config.relations),
-                files: createFilesSchema(name, schema.config.files),
+                relations: createRelationsSchema(name, schema.config.relations, idColumnOf),
+                files: createFilesSchema(name, schema.config.files, idColumnOf('File')),
                 audit: createAuditSchema(name, authModel, schema.config.audit),
                 index: createIndexSchema(schema.config.index),
                 tableName: schema.config.tableName
@@ -84,7 +106,7 @@ async function generateSchema(models, schemaPath, clientPath, quiet = false) {
         for (const [name, model] of Object.entries(prismaModels)) {
             const modelSchema = Object.entries(models).find(([key]) => key === name)?.[1];
             for (const relation of model.relations) {
-                if (relation.type.startsWith('Int')) {
+                if (relation.foreignKey) {
                     continue;
                 }
                 const relationConfig = modelSchema?.config.relations?.[relation.name];
@@ -97,7 +119,7 @@ async function generateSchema(models, schemaPath, clientPath, quiet = false) {
                     .replaceAll('?', '');
                 const referencedModel = prismaModels[referencedName];
                 const mappedField = referencedModel.relations.find((r) => r.name === relationConfig.mappedBy);
-                if (mappedField?.type.startsWith('Int')) {
+                if (mappedField?.foreignKey) {
                     continue;
                 }
                 if (mappedField && mappedField.attributes?.length) {
@@ -136,6 +158,7 @@ async function generateSchema(models, schemaPath, clientPath, quiet = false) {
                         const refName = (0, common_1.uncapitalize)(name);
                         const refFieldName = `${refName}Id`;
                         if (!referencedModel.relations.some((r) => r.name === refName)) {
+                            const idColumn = idColumnOf(name);
                             referencedModel.relations.push({
                                 name: refName,
                                 type: `${name}?`,
@@ -145,8 +168,12 @@ async function generateSchema(models, schemaPath, clientPath, quiet = false) {
                             });
                             referencedModel.relations.push({
                                 name: refFieldName,
-                                type: 'Int?',
-                                attributes: relationConfig.type === 'oneToOne' ? ['@unique'] : []
+                                type: `${idColumn.type}?`,
+                                attributes: [
+                                    ...(relationConfig.type === 'oneToOne' ? ['@unique'] : []),
+                                    ...nativeTypeAttributes(idColumn.nativeType)
+                                ],
+                                foreignKey: true
                             });
                         }
                     }
@@ -299,15 +326,64 @@ function calculateMaxLengths(fields) {
     }
     return { nameLength, typeLength };
 }
-function createIdSchema(id = {}) {
-    const defaultType = !id.generator || id.generator === 'autoincrement()' ? 'Int' : 'String';
-    const defaultGenerator = id.type !== 'string' ? 'autoincrement()' : 'uuid()';
+function prismaIdType(id) {
+    switch ((0, common_1.idFieldType)(id)) {
+        case 'string':
+            return 'String';
+        case 'bigInt':
+            return 'BigInt';
+        default:
+            return 'Int';
+    }
+}
+function parseGenerator(generator) {
+    const match = generator?.match(/^(\w+)\(([^)]*)\)$/);
+    return match ? { name: match[1], arg: match[2].trim() } : undefined;
+}
+function generatorNativeType(generator, dbType = databaseType()) {
+    if (dbType === common_1.DatabaseType.Sqlite) {
+        return undefined;
+    }
+    const parsed = parseGenerator(generator);
+    if (!parsed) {
+        return undefined;
+    }
+    // The argument of `uuid()` and `cuid()` selects the version, the one of
+    // `nanoid()` the length of the generated value
+    switch (parsed.name) {
+        case 'uuid':
+            return UUID_NATIVE_TYPES[dbType] ?? `@db.VarChar(${UUID_LENGTH})`;
+        case 'cuid':
+            return varCharType(CUID_LENGTHS[parsed.arg]);
+        case 'nanoid':
+            return varCharType(parsed.arg ? Number(parsed.arg) : NANOID_LENGTH, NANOID_LENGTH);
+        default:
+            return undefined;
+    }
+}
+function varCharType(length, fallback) {
+    const size = Number.isFinite(length) ? length : fallback;
+    return size ? `@db.VarChar(${size})` : undefined;
+}
+function idNativeType(id) {
+    return (0, common_1.idFieldType)(id) === 'string'
+        ? generatorNativeType((0, common_1.idFieldGenerator)(id))
+        : undefined;
+}
+function createIdSchema(id) {
     return {
         name: 'id',
-        type: (0, common_1.capitalize)(id.type ?? defaultType),
-        attributes: ['@id', `@default(${id.generator ?? defaultGenerator})`]
+        type: prismaIdType(id),
+        attributes: [
+            '@id',
+            `@default(${(0, common_1.idFieldGenerator)(id)})`,
+            ...nativeTypeAttributes(idNativeType(id))
+        ]
     };
 }
+function nativeTypeAttributes(nativeType) {
+    return nativeType ? [nativeType] : [];
+}
 function createScalarsSchema(modelName, scalars = {}) {
     const fields = [];
     for (const [name, scalar] of Object.entries(scalars)) {
@@ -368,8 +444,13 @@ function createScalarSchema(name, modelName, scalar) {
     if (defaultAttribute) {
         attributes.push(defaultAttribute);
     }
-    if (scalar.type === 'string' && scalar.maxLength && !isSqlite) {
-        attributes.push(`@db.VarChar(${scalar.maxLength})`);
+    if (scalar.type === 'string' && !isSqlite) {
+        // The generator width wins over `maxLength`, which only bounds the API input
+        const nativeType = generatorNativeType(scalar.defaultGenerator) ??
+            varCharType(scalar.maxLength);
+        if (nativeType) {
+            attributes.push(nativeType);
+        }
     }
     return {
         name,
@@ -430,14 +511,14 @@ function validateRelations(models) {
     }
     return errors;
 }
-function createRelationsSchema(modelName, relations = {}) {
+function createRelationsSchema(modelName, relations = {}, idColumnOf = defaultIdColumn) {
     const fields = [];
     for (const [name, relation] of Object.entries(relations)) {
-        fields.push(...createRelationSchema(name, modelName, relation));
+        fields.push(...createRelationSchema(name, modelName, relation, idColumnOf(relation.model)));
     }
     return fields;
 }
-function createRelationSchema(name, modelName, relation) {
+function createRelationSchema(name, modelName, relation, relationIdColumn = defaultIdColumn()) {
     const attributes = [];
     const relationName = `${modelName}${(0, common_1.capitalize)(name)}${relation.model}`;
     const relationFieldName = `${name}Id`;
@@ -479,20 +560,24 @@ function createRelationSchema(name, modelName, relation) {
     if (owner) {
         relationFields.push({
             name: relationFieldName,
-            type: `Int${relationSuffix}`,
-            attributes: relation.type === 'oneToOne' ? ['@unique'] : []
+            type: `${relationIdColumn.type}${relationSuffix}`,
+            attributes: [
+                ...(relation.type === 'oneToOne' ? ['@unique'] : []),
+                ...nativeTypeAttributes(relationIdColumn.nativeType)
+            ],
+            foreignKey: true
         });
     }
     return relationFields;
 }
-function createFilesSchema(modelName, files = {}) {
+function createFilesSchema(modelName, files = {}, fileIdColumn = defaultIdColumn()) {
     const fields = [];
     for (const [name, file] of Object.entries(files)) {
-        fields.push(...createFileSchema(name, modelName, file));
+        fields.push(...createFileSchema(name, modelName, file, fileIdColumn));
     }
     return fields;
 }
-function createFileSchema(name, modelName, file) {
+function createFileSchema(name, modelName, file, fileIdColumn = defaultIdColumn()) {
     const attributes = [];
     const type = file.array ? 'File[]' : 'File?';
     const fileRelationName = `${modelName}${(0, common_1.capitalize)(name)}File`;
@@ -513,8 +598,9 @@ function createFileSchema(name, modelName, file) {
     if (!file.array) {
         fileFields.push({
             name: fileRelationFieldName,
-            type: 'Int?',
-            attributes: ['@unique']
+            type: `${fileIdColumn.type}?`,
+            attributes: ['@unique', ...nativeTypeAttributes(fileIdColumn.nativeType)],
+            foreignKey: true
         });
     }
     return fileFields;
@@ -552,7 +638,9 @@ function createAuditSchema(modelName, authModel, audit = {}) {
         });
         fields.push({
             name: 'createdById',
-            type: 'Int?'
+            type: `${prismaIdType(authModel?.config.id)}?`,
+            attributes: nativeTypeAttributes(idNativeType(authModel?.config.id)),
+            foreignKey: true
         });
     }
     return fields;
@@ -563,7 +651,9 @@ function createIndexSchema(index) {
         return indexes;
     }
     for (const idx of index) {
-        const indexValue = (0, common_1.isArray)(idx) ? `[${idx.join(', ')}]` : idx;
+        const indexValue = (0, common_1.isArray)(idx)
+            ? `[${idx.map(indexFieldSchema).join(', ')}]`
+            : indexFieldSchema(idx);
         const indexExpression = `@@index(${indexValue})`;
         if (!indexes.includes(indexExpression)) {
             indexes.push(indexExpression);
@@ -571,6 +661,13 @@ function createIndexSchema(index) {
     }
     return indexes;
 }
+function indexFieldSchema(field) {
+    const sort = INDEX_SORT_PREFIXES[field.charAt(0)];
+    if (!sort || field.length < 2) {
+        return field;
+    }
+    return `${field.slice(1)}(sort: ${sort})`;
+}
 function databaseType() {
     return (0, common_1.resolveDatabaseType)(common_1.config.DATABASE_TYPE, common_1.config.DATABASE_URL);
 }

package/generate/generate-types.js

@@ -52,7 +52,7 @@ async function generateTypes(models, typesPath, quiet = false) {
             ``
         ];
         if (Object.keys(modelTypeNames).length > 0) {
-            typesContent.push(`import { AggregateSelect, QueryFilter, QuerySort } from '@appweaver/common';`, ``);
+            typesContent.push(`import { AggregateSelect, IResourceService, QueryFilter, QuerySort } from '@appweaver/common';`, ``);
         }
         for (const [name, typeNames] of Object.entries(modelTypeNames)) {
             for (const typeName of typeNames) {
@@ -63,6 +63,9 @@ async function generateTypes(models, typesPath, quiet = false) {
             // the relations included in a query response and their count fields
             typesContent.push(`export type ${name}Sort = QuerySort<${name}Multiple>;`, ``);
             typesContent.push(`export type ${name}Aggregate = AggregateSelect<${name}>;`, ``);
+            // Emitted last, with the arguments making the aliases above exactly the
+            // inputs its methods accept
+            typesContent.push(`export type ${name}ResourceService = IResourceService<${name}, ${name}Multiple, ${name}Create, ${name}Update, ${name}Query>;`, ``);
         }
         const outputPath = node_path_1.default.join(cwd, typesPath);
         const prettierConfig = await prettier_1.default.resolveConfig(outputPath);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@appweaver/cli",
-  "version": "1.3.1",
+  "version": "1.4.0",
   "description": "Appweaver - the backend framework for AI-first development (@cli)",
   "author": "Luka Matosevic",
   "license": "MIT",

package/skill/GUIDELINES.md

@@ -84,6 +84,9 @@ export default createModel({
 });
 ```
 
+Index entries are field names, nested in an array for a composite index (`[['status', 'createdAt']]`). Prefix a name
+with `-` for a descending index or `+` for an ascending one (`['-createdAt']`); unprefixed uses the database default.
+
 ### Service
 
 ```ts
@@ -101,6 +104,15 @@ export default createService({
 });
 ```
 
+Inject a resource service anywhere with the `<Model>ResourceService` alias `weaver generate` emits per model:
+
+```ts
+import { injectService } from '@appweaver/core';
+import { ProductResourceService } from '@/types/generated';
+
+const products = injectService<ProductResourceService>('Product');
+```
+
 ### Routes
 
 ```ts
@@ -141,9 +153,10 @@ Use `createAuthModel` and `createAuthService` for authenticatable users. They mu
 `createAuthModel` adds: `email`, `passwordHash`, `verifiedEmail`, `twoFactorAuth`, `enabled`, `logoutAt` scalars; a
 virtual `password` field; a `roles` relation; and optional `apiKeys` relation.
 
-`createAuthService` supports an optional `registrationData` callback to customize the registration payload and an
-optional `checkOAuth2User` callback to allow or reject OAuth2 registrations/logins (return nothing to proceed, or a
-string/`Error` to abort).
+`createAuthService` supports an optional `registrationData` callback to customize the registration payload, an optional
+`registrationFiles` callback that stores files on the model's file fields right after the user is created (used to keep
+the avatar an OAuth2 provider serves), and an optional `checkOAuth2User` callback to allow or reject OAuth2
+registrations/logins (return nothing to proceed, or a string/`Error` to abort).
 
 ```ts
 // src/resources/user/model.ts
@@ -162,7 +175,8 @@ import { createAuthService } from '@appweaver/core';
 
 export default createAuthService({
   modelName: 'User',
-  registrationData: (_, email, password) => ({ email, password, roles: [1, 2] })
+  registrationData: (_, email, password) => ({ email, password, roles: [1, 2] }),
+  registrationFiles: (_, data) => ({ avatar: data?.avatarFile })
 });
 ```