sindri/source/outputs/database_sqlite.ts

namespace _sindri.outputs.database.sqlite
{
	
	/**
	 */
	function value_encode(
		value : any
	) : string
	{
		if (value === null) {
			return "NULL";
		}
		else {
			switch (typeof(value)) {
				case "boolean": {
					return (value ? "TRUE" : "FALSE");
					break;
				}
				case "number": {
					return value.toString();
					break;
				}
				case "string": {
					return ("'" + value + "'");
					break;
				}
				default: {
					throw (new Error("unhandled"));
					break;
				}
			}
		}
	}
	
	
	/**
	 */
	export function render(
		input_data
	) : string
	{
		return (
			input_data["domains"]
			.map(
				(domain) => lib_plankton.string.coin(
					"CREATE TABLE\n\t`{{name}}`(\n{{entries}}\n\t)\n;",
					{
						"name": domain.name,
						"entries": (
							(
								[]
								// key field
								.concat(
									(domain.key_field === null)
									? []
									: lib_plankton.string.coin(
										"`{{name}}` {{parameters}}",
										{
											"name": domain.key_field.name,
											"parameters": (
												[
													"INTEGER",
													"PRIMARY KEY",
													"AUTOINCREMENT",
												]
												.join(" ")
											),
										}
									)
								)
								// data fields
								.concat(
									domain.data_fields
									.map(
										(data_field) => lib_plankton.string.coin(
											"`{{name}}` {{parameters}}",
											{
												"name": data_field.name,
												"parameters": (
													(
														// type
														[
															{
																"boolean": "BOOLEAN",
																"integer": "INTEGER",
																"string_short": "VARCHAR(63)",
																"string_medium": "VARCHAR(255)",
																"string_long": "TEXT",
															}[data_field.type],
														]
														// nullability
														.concat(
															data_field.nullable
															? ["NULL"]
															: []
														)
														// default
														.concat(
															(data_field.default === undefined)
															? []
															: [
																lib_plankton.string.coin(
																	"DEFAULT {{value}}",
																	{
																		"value": value_encode(data_field.default),
																	}
																),
															]
														)
													)
													.join(" ")
												)
											}
										)
									)
								)
								// constraints
								.concat(
									domain.constraints
									.map(
										(constraint) => {
											switch (constraint.kind) {
												default: {
													throw (new Error("unhandled constraint kind: " + constraint.kind));
													break;
												}
												case "foreign_key": {
													return lib_plankton.string.coin(
														"FOREIGN KEY ({{fields}}) REFERENCES `{{reference_name}}`({{reference_fields}})",
														{
															"fields": (
																constraint.parameters["fields"]
																.map(x => ('`' + x + '`'))
																.join(",")
															),
															"reference_name": constraint.parameters["reference"]["name"],
															"reference_fields": (
																constraint.parameters["reference"]["fields"]
																.map(x => ('`' + x + '`'))
																.join(",")
															),
														}
													);
													break;
												}
												case "unique": {
													return lib_plankton.string.coin(
														"UNIQUE ({{fields}})",
														{
															"fields": (
																constraint.parameters["fields"]
																.map(x => ('`' + x + '`'))
																.join(",")
															),
														}
													);
													break;
												}
											}
										}
									)
								)
							)
							.map(x => ("\t\t" + x))
							.join(",\n")
						),
					}
				)
			)
			.map(x => (x + "\n"))
			.join("\n")
		);
	}
	
}

const output_database_sqlite : type_output = {
	"render": _sindri.outputs.database.sqlite.render,
};