prisma-rust-schema 0.2.1

A Rust binary to act as a Prisma generator, generating Rust code from Prisma schema files.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134

use serde::{Deserialize, Serialize};
use std::collections::HashMap;

use crate::{dmmf::Document, typed_sql::SqlQueryOutput};

#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct EnvValue {
    pub from_env_var: Option<String>,
    pub value: Option<String>,
}

#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct BinaryTargetsEnvValue {
    pub from_env_var: Option<String>,
    pub value: String,
    pub native: Option<bool>,
}

#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct GeneratorConfig {
    pub name: String,
    pub output: Option<EnvValue>,
    pub is_custom_output: Option<bool>,
    pub provider: EnvValue,
    pub config: HashMap<String, Option<String>>,
    pub binary_targets: Vec<BinaryTargetsEnvValue>,
    pub preview_features: Vec<String>,
    pub env_paths: Option<EnvPaths>,
    pub source_file_path: String,
}

#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct EnvPaths {
    pub root_env_path: Option<String>,
    pub schema_env_path: Option<String>,
}

#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, Eq)]
#[serde(rename_all = "lowercase")]
pub enum ConnectorType {
    Mysql,
    Mongodb,
    Sqlite,
    Postgresql,
    Postgres,
    #[serde(rename = "prisma+postgres")]
    /// Note: used for Prisma Postgres, managed by PDP
    PrismaPostgres,
    Sqlserver,
    Cockroachdb,
}

#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, Eq)]
#[serde(rename_all = "lowercase")]
pub enum ActiveConnectorType {
    Mysql,
    Mongodb,
    Sqlite,
    Postgresql,
    Sqlserver,
    Cockroachdb,
}

#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct DataSource {
    pub name: String,
    pub provider: ConnectorType,
    pub active_provider: ActiveConnectorType,
    pub url: EnvValue,
    pub direct_url: Option<EnvValue>,
    pub schemas: Vec<String>,
    pub source_file_path: String,
}

#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct BinaryPaths {
    /// key: target, value: path
    pub schema_engine: Option<HashMap<String, String>>,
    pub query_engine: Option<HashMap<String, String>>,
    pub libquery_engine: Option<HashMap<String, String>>,
}

#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct GeneratorOptions {
    pub generator: GeneratorConfig,
    pub other_generators: Vec<GeneratorConfig>,
    pub schema_path: String,
    pub dmmf: Document,
    pub datasources: Vec<DataSource>,
    pub datamodel: String,
    /// Hash of the version
    pub version: String,
    pub binary_paths: Option<BinaryPaths>,
    pub postinstall: Option<bool>,
    pub no_engine: Option<bool>,
    pub no_hints: Option<bool>,
    pub allow_no_models: Option<bool>,
    pub env_paths: Option<EnvPaths>,
    pub typed_sql: Option<Vec<SqlQueryOutput>>,
}

#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, Eq)]
#[serde(rename_all = "camelCase")]
#[allow(clippy::enum_variant_names)]
pub enum EngineType {
    QueryEngine,
    LibqueryEngine,
    SchemaEngine,
}

#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct GeneratorManifest {
    pub pretty_name: Option<String>,
    pub default_output: Option<String>,
    pub denylists: Option<DenyLists>,
    pub requires_generators: Option<Vec<String>>,
    pub requires_engines: Option<Vec<EngineType>>,
    pub version: Option<String>,
    pub requires_engine_version: Option<String>,
}

#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct DenyLists {
    pub models: Option<Vec<String>>,
    pub fields: Option<Vec<String>>,
}