@zenstackhq/sdk 3.8.3 → 3.9.0

package/dist/index.d.cts

@@ -108,6 +108,7 @@ declare class PrismaSchemaGenerator {
   private datasourceHasSchemasSetting;
   private getDefaultPostgresSchemaName;
   private isPrismaAttribute;
+  private isNativeTypeMappingAttribute;
   private getUnsupportedFieldType;
   private generateModelField;
   private isDefaultWithAuthInvocation;
@@ -156,6 +157,8 @@ declare class TsSchemaGenerator {
   private getSubModels;
   private createTypeDefObject;
   private createComputedFieldsObject;
+  private createFieldParamsObject;
+  private mapFunctionParamTypeToTSType;
   private createUpdatedAtObject;
   private mapFieldTypeToTSType;
   private createDataFieldObject;

package/dist/index.d.mts

@@ -108,6 +108,7 @@ declare class PrismaSchemaGenerator {
   private datasourceHasSchemasSetting;
   private getDefaultPostgresSchemaName;
   private isPrismaAttribute;
+  private isNativeTypeMappingAttribute;
   private getUnsupportedFieldType;
   private generateModelField;
   private isDefaultWithAuthInvocation;
@@ -156,6 +157,8 @@ declare class TsSchemaGenerator {
   private getSubModels;
   private createTypeDefObject;
   private createComputedFieldsObject;
+  private createFieldParamsObject;
+  private mapFunctionParamTypeToTSType;
   private createUpdatedAtObject;
   private mapFieldTypeToTSType;
   private createDataFieldObject;

package/dist/index.mjs

@@ -493,6 +493,9 @@ var PrismaSchemaGenerator = class {
 		if (!attr.decl.ref) return false;
 		return attr.decl.ref.attributes.some((a) => a.decl.ref?.name === "@@@prisma");
 	}
+	isNativeTypeMappingAttribute(attr) {
+		return attr.decl.$refText.startsWith("@db.") && this.isPrismaAttribute(attr);
+	}
 	getUnsupportedFieldType(fieldType) {
 		if (fieldType.unsupported) {
 			const value = getStringLiteral(fieldType.unsupported.value);
@@ -523,7 +526,11 @@ var PrismaSchemaGenerator = class {
 		return AstUtils.streamAst(expr).some(isAuthInvocation);
 	}
 	makeFieldAttribute(attr) {
-		const attrName = attr.decl.ref.name;
+		let attrName = attr.decl.ref.name;
+		if (this.isNativeTypeMappingAttribute(attr)) {
+			const dataSource = this.zmodel.declarations.find(isDataSource);
+			if (dataSource) attrName = attrName.replace("@db", `@${dataSource.name}`);
+		}
 		return new FieldAttribute(attrName, attr.args.map((arg) => this.makeAttributeArg(arg)));
 	}
 	makeAttributeArg(arg) {
@@ -751,7 +758,24 @@ var TsSchemaGenerator = class {
 		return ts.factory.createObjectLiteralExpression(fields, true);
 	}
 	createComputedFieldsObject(fields) {
-		return ts.factory.createObjectLiteralExpression(fields.map((field) => ts.factory.createMethodDeclaration(void 0, void 0, field.name, void 0, void 0, [ts.factory.createParameterDeclaration(void 0, void 0, "_context", void 0, ts.factory.createTypeLiteralNode([ts.factory.createPropertySignature(void 0, "modelAlias", void 0, ts.factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword))]), void 0)], ts.factory.createTypeReferenceNode(this.mapFieldTypeToTSType(field.type)), ts.factory.createBlock([ts.factory.createThrowStatement(ts.factory.createNewExpression(ts.factory.createIdentifier("Error"), void 0, [ts.factory.createStringLiteral("This is a stub for computed field")]))], true))), true);
+		return ts.factory.createObjectLiteralExpression(fields.map((field) => {
+			const params = [ts.factory.createParameterDeclaration(void 0, void 0, "_context", void 0, ts.factory.createTypeLiteralNode([ts.factory.createPropertySignature(void 0, "modelAlias", void 0, ts.factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword))]), void 0)];
+			if (field.params.length > 0) params.push(ts.factory.createParameterDeclaration(void 0, void 0, "args", void 0, ts.factory.createTypeLiteralNode(field.params.map((param) => ts.factory.createPropertySignature(void 0, param.name, param.optional ? ts.factory.createToken(ts.SyntaxKind.QuestionToken) : void 0, ts.factory.createTypeReferenceNode(this.mapFunctionParamTypeToTSType(param.type))))), void 0));
+			return ts.factory.createMethodDeclaration(void 0, void 0, field.name, void 0, void 0, params, ts.factory.createTypeReferenceNode(this.mapFieldTypeToTSType(field.type)), ts.factory.createBlock([ts.factory.createThrowStatement(ts.factory.createNewExpression(ts.factory.createIdentifier("Error"), void 0, [ts.factory.createStringLiteral("This is a stub for computed field")]))], true));
+		}), true);
+	}
+	createFieldParamsObject(params) {
+		return ts.factory.createObjectLiteralExpression(params.map((param) => ts.factory.createPropertyAssignment(param.name, ts.factory.createObjectLiteralExpression([
+			ts.factory.createPropertyAssignment("name", ts.factory.createStringLiteral(param.name)),
+			...param.optional ? [ts.factory.createPropertyAssignment("optional", ts.factory.createTrue())] : [],
+			...param.type.array ? [ts.factory.createPropertyAssignment("array", ts.factory.createTrue())] : [],
+			ts.factory.createPropertyAssignment("type", ts.factory.createStringLiteral(param.type.type ?? param.type.reference.$refText))
+		]))), true);
+	}
+	mapFunctionParamTypeToTSType(type) {
+		let result = match(type.type).with("String", () => "string").with("Boolean", () => "boolean").with("Int", () => "number").with("Float", () => "number").with("BigInt", () => "bigint").with("Decimal", () => "number").with("DateTime", () => "Date").otherwise(() => "unknown");
+		if (type.array) result = `${result}[]`;
+		return result;
 	}
 	createUpdatedAtObject(ignoreArg) {
 		return ts.factory.createObjectLiteralExpression([ts.factory.createPropertyAssignment("ignore", ts.factory.createArrayLiteralExpression(ignoreArg.value.items.map((item) => ts.factory.createStringLiteral(item.target.$refText))))]);
@@ -794,6 +818,7 @@ var TsSchemaGenerator = class {
 			objectFields.push(ts.factory.createPropertyAssignment("default", this.createDefaultTypeAssertion(defaultExpr)));
 		}
 		if (hasAttribute(field, "@computed")) objectFields.push(ts.factory.createPropertyAssignment("computed", ts.factory.createTrue()));
+		if (field.params.length > 0) objectFields.push(ts.factory.createPropertyAssignment("params", this.createFieldParamsObject(field.params)));
 		if (isDataModel(field.type.reference?.ref)) objectFields.push(ts.factory.createPropertyAssignment("relation", this.createRelationObject(field, contextModel)));
 		const fkFor = this.getForeignKeyFor(field, contextModel);
 		if (fkFor && fkFor.length > 0) objectFields.push(ts.factory.createPropertyAssignment("foreignKeyFor", ts.factory.createAsExpression(ts.factory.createArrayLiteralExpression(fkFor.map((fk) => ts.factory.createStringLiteral(fk)), true), ts.factory.createTypeOperatorNode(ts.SyntaxKind.ReadonlyKeyword, ts.factory.createArrayTypeNode(ts.factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword))))));
@@ -906,9 +931,9 @@ var TsSchemaGenerator = class {
 		const relationName = this.getRelationName(field);
 		for (const otherField of getAllFields(targetModel)) {
 			if (otherField === field) continue;
-			if (otherField.type.reference?.ref === sourceModel) if (relationName) {
+			if (otherField.type.reference?.ref === sourceModel) {
 				if (this.getRelationName(otherField) === relationName) return otherField;
-			} else return otherField;
+			}
 		}
 	}
 	getRelationName(field) {