@rebasepro/server-postgres 0.17.3 → 0.18.1

package/dist/generate-drizzle-schema-logic-so2Z_lyC.js

@@ -0,0 +1,528 @@
+import { createRequire as __createRequire } from "module";
+__createRequire(import.meta.url);
+import { t as defaultBelongsToOnDelete, v as buildSearchColumnSpec } from "./generate-postgres-ddl-logic-CtnpIBVv.js";
+import { logger } from "@rebasepro/server";
+import { hasForeignKeyOnTarget, isManyToMany, isPostgresCollectionConfig } from "@rebasepro/types";
+import { fieldKeyForColumn, findRelation, getEffectiveSecurityRules, getEnumVarName, getJunctionCollectionConfig, getJunctionSecurityRules, getTableName, getTableVarName, policyToPostgres, relationalCollections, resolveCollectionRelations, resolveJunctionSpecs, resolveStringColumnLength, securityRuleToConditions, sortCollectionsBySlug } from "@rebasepro/common";
+import { getPolicyNamesForRule, toSnakeCase } from "@rebasepro/utils";
+//#region src/schema/generate-drizzle-schema-logic.ts
+/**
+* Resolve the SQL column name for a property.
+* Uses the explicit `columnName` when set (e.g. from introspection),
+* falling back to `toSnakeCase(propName)` for manually-authored collections.
+*/
+var JS_IDENTIFIER = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+/**
+* A string literal for the generated schema file.
+*
+* Column names, table names and enum values are all written into this file as
+* literals, and none of them is constrained to be quote-free: a Postgres
+* identifier only has to be quoted, and `O'Brien` is an ordinary enum value.
+* Interpolating them raw ended the literal early — for enum values, inside
+* single quotes, where an apostrophe is not an edge case.
+*/
+var quote = (value) => JSON.stringify(value);
+/** An object key: verbatim when it is an identifier, quoted otherwise. */
+var propKey = (name) => JS_IDENTIFIER.test(name) ? name : quote(name);
+/**
+* A property access on a generated table variable.
+*
+* `users.full name` is not an expression; `users["full name"]` is, and Drizzle
+* treats the two identically.
+*/
+var member = (object, key) => JS_IDENTIFIER.test(key) ? `${object}.${key}` : `${object}[${quote(key)}]`;
+var resolveColumnName = (propName, prop) => {
+	if (prop && "columnName" in prop && typeof prop.columnName === "string") return prop.columnName;
+	return toSnakeCase(propName);
+};
+var getPrimaryKeyProp = (collection) => {
+	if (collection.properties) {
+		const idPropEntry = Object.entries(collection.properties).find(([_, prop]) => "isId" in prop && Boolean(prop.isId));
+		if (idPropEntry) {
+			const prop = idPropEntry[1];
+			const isUuid = prop.type === "string" && "isId" in prop && prop.isId === "uuid";
+			return {
+				name: idPropEntry[0],
+				type: prop.type === "number" ? "number" : "string",
+				isUuid
+			};
+		}
+	}
+	const idProp = collection.properties?.["id"];
+	if (idProp?.type === "number") return {
+		name: "id",
+		type: "number",
+		isUuid: false
+	};
+	return {
+		name: "id",
+		type: "string",
+		isUuid: idProp?.type === "string" && "isId" in idProp && idProp.isId === "uuid"
+	};
+};
+/**
+* Given a raw DB column name (e.g. "client_id"), the Drizzle property key that
+* maps to it.
+*
+* One line, because the rule is shared: the Drizzle object key is the wire
+* name, and {@link fieldKeyForColumn} is the one definition of what a column is
+* named on the wire. This used to be a private copy that fell back to the
+* column verbatim, which is how a derived foreign key ended up served as
+* `author_id` beside a hand-authored `displayName`.
+*/
+var resolvePropertyKeyForColumn = (collection, column) => fieldKeyForColumn(collection, column);
+var isNumericId = (collection) => {
+	return getPrimaryKeyProp(collection).type === "number";
+};
+var getPrimaryKeyName = (collection) => {
+	return getPrimaryKeyProp(collection).name;
+};
+var isIdProperty = (propName, prop, collection) => {
+	if ("isId" in prop && Boolean(prop.isId)) return true;
+	return !Object.values(collection.properties ?? {}).some((p) => "isId" in p && Boolean(p.isId)) && propName === "id";
+};
+/**
+* The Drizzle column declaration a property compiles to, or `null` when the
+* property puts no column on *this* table (an inverse relation, whose column
+* lives on the target). Exported so it can be checked against its DDL twin
+* `getSqlColumnType` directly — the two disagreeing is what left `geopoint`
+* with a database column and no Drizzle key.
+*/
+var getDrizzleColumn = (propName, prop, collection, collections) => {
+	const colName = resolveColumnName(propName, prop);
+	let columnDefinition;
+	switch (prop.type) {
+		case "string": {
+			const stringProp = prop;
+			if (stringProp.enum) columnDefinition = `${getEnumVarName(getTableName(collection), propName)}(${quote(colName)})`;
+			else if ("isId" in stringProp && stringProp.isId === "uuid") columnDefinition = `uuid(${quote(colName)})`;
+			else if (stringProp.columnType === "uuid") columnDefinition = `uuid(${quote(colName)})`;
+			else if (stringProp.columnType === "char") columnDefinition = `char(${quote(colName)}, { length: ${resolveStringColumnLength(stringProp)} })`;
+			else if (stringProp.columnType === "varchar") columnDefinition = `varchar(${quote(colName)}, { length: ${resolveStringColumnLength(stringProp)} })`;
+			else columnDefinition = `text(${quote(colName)})`;
+			if (isIdProperty(propName, prop, collection)) columnDefinition += ".primaryKey()";
+			if ("isId" in stringProp && stringProp.isId !== "manual" && stringProp.isId !== true) {
+				if (stringProp.isId === "uuid") columnDefinition += ".defaultRandom()";
+				else if (stringProp.isId === "cuid") columnDefinition += ".default(sql`cuid()`)";
+				else if (typeof stringProp.isId === "string") {
+					const sqlContent = stringProp.isId.startsWith("sql`") && stringProp.isId.endsWith("`") ? stringProp.isId.substring(4, stringProp.isId.length - 1) : stringProp.isId;
+					columnDefinition += `.default(sql\`${sqlContent}\`)`;
+				}
+			}
+			if (stringProp.validation?.unique) columnDefinition += ".unique()";
+			break;
+		}
+		case "number": {
+			const numProp = prop;
+			const isId = isIdProperty(propName, prop, collection);
+			let baseType = numProp.validation?.integer || isId ? `integer(${quote(colName)})` : `numeric(${quote(colName)})`;
+			if (numProp.columnType) if (numProp.columnType === "double precision") baseType = `doublePrecision(${quote(colName)})`;
+			else if (numProp.columnType === "bigint" || numProp.columnType === "bigserial") baseType = `${numProp.columnType}(${quote(colName)}, { mode: "number" })`;
+			else baseType = `${numProp.columnType}(${quote(colName)})`;
+			if ("isId" in numProp && numProp.isId === "increment") columnDefinition = `${baseType}.generatedByDefaultAsIdentity()`;
+			else if ("isId" in numProp && typeof numProp.isId === "string" && numProp.isId !== "manual") {
+				columnDefinition = baseType;
+				const sqlContent = numProp.isId.startsWith("sql`") && numProp.isId.endsWith("`") ? numProp.isId.substring(4, numProp.isId.length - 1) : numProp.isId;
+				columnDefinition += `.default(sql\`${sqlContent}\`)`;
+			} else columnDefinition = baseType;
+			if (isId) columnDefinition += ".primaryKey()";
+			if (numProp.validation?.unique) columnDefinition += ".unique()";
+			break;
+		}
+		case "boolean":
+			columnDefinition = `boolean(${quote(colName)})`;
+			break;
+		case "date": {
+			const dateProp = prop;
+			if (dateProp.columnType === "date") columnDefinition = `date(${quote(colName)}, { mode: 'string' })`;
+			else if (dateProp.columnType === "time") columnDefinition = `time(${quote(colName)})`;
+			else columnDefinition = `timestamp(${quote(colName)}, { withTimezone: true, mode: 'string' })`;
+			if (dateProp.autoValue === "on_create" || dateProp.autoValue === "on_update") columnDefinition += ".default(sql`now()`)";
+			break;
+		}
+		case "map":
+			if (prop.columnType === "json") columnDefinition = `json(${quote(colName)})`;
+			else columnDefinition = `jsonb(${quote(colName)})`;
+			break;
+		case "geopoint":
+			columnDefinition = `jsonb(${quote(colName)})`;
+			break;
+		case "array": {
+			const arrayProp = prop;
+			let colType = arrayProp.columnType;
+			if (!colType && arrayProp.of && !Array.isArray(arrayProp.of)) {
+				const ofProp = arrayProp.of;
+				if (ofProp.type === "string") colType = "text[]";
+				else if (ofProp.type === "number") colType = ofProp.validation?.integer ? "integer[]" : "numeric[]";
+				else if (ofProp.type === "boolean") colType = "boolean[]";
+			}
+			if (colType === "json") columnDefinition = `json(${quote(colName)})`;
+			else if (colType === "text[]") columnDefinition = `text(${quote(colName)}).array()`;
+			else if (colType === "integer[]") columnDefinition = `integer(${quote(colName)}).array()`;
+			else if (colType === "boolean[]") columnDefinition = `boolean(${quote(colName)}).array()`;
+			else if (colType === "numeric[]") columnDefinition = `numeric(${quote(colName)}).array()`;
+			else columnDefinition = `jsonb(${quote(colName)})`;
+			break;
+		}
+		case "vector": {
+			const vp = prop;
+			columnDefinition = `vector(${quote(colName)}, { dimensions: ${vp.dimensions} })`;
+			break;
+		}
+		case "binary":
+			columnDefinition = `customType({ dataType() { return 'bytea'; } })(${quote(colName)})`;
+			break;
+		case "relation": {
+			const refProp = prop;
+			const relation = findRelation(resolveCollectionRelations(collection), refProp.relation?.relationName ?? propName);
+			if (!relation || relation.kind !== "belongsTo") return null;
+			const fkFieldKey = fieldKeyForColumn(collection, relation.localKey);
+			if (collection.properties[fkFieldKey] && propName !== fkFieldKey) return null;
+			let targetCollection;
+			try {
+				targetCollection = relation.target();
+			} catch {
+				return null;
+			}
+			const fkColumnName = relation.localKey;
+			const targetTableVar = getTableVarName(getTableName(targetCollection));
+			const pkProp = getPrimaryKeyProp(targetCollection);
+			const targetIdField = pkProp.name;
+			const baseColumn = pkProp.type === "number" ? `integer(${quote(fkColumnName)})` : pkProp.isUuid ? `uuid(${quote(fkColumnName)})` : `text(${quote(fkColumnName)})`;
+			const onUpdate = relation.onUpdate ? `onUpdate: "${relation.onUpdate}"` : "";
+			const required = prop.validation?.required;
+			const refOptionsParts = [onUpdate, `onDelete: \"${relation.onDelete ?? defaultBelongsToOnDelete(required).toLowerCase()}\"`].filter(Boolean);
+			const refOptions = refOptionsParts.length > 0 ? `{ ${refOptionsParts.join(", ")} }` : "";
+			let columnDef = `${baseColumn}.references(() => ${member(targetTableVar, targetIdField)}${refOptions ? `, ${refOptions}` : ""})`;
+			if (required) columnDef += ".notNull()";
+			return `    ${propKey(fkFieldKey)}: ${columnDef}`;
+		}
+		case "reference": {
+			const refProp = prop;
+			const targetCollection = collections.find((c) => c.slug === refProp.path || getTableName(c) === refProp.path);
+			if (!targetCollection) {
+				columnDefinition = `text(${quote(colName)})`;
+				break;
+			}
+			const pkProp = getPrimaryKeyProp(targetCollection);
+			const targetTableVar = getTableVarName(getTableName(targetCollection));
+			const targetIdField = pkProp.name;
+			const baseColumn = pkProp.type === "number" ? `integer(${quote(colName)})` : pkProp.isUuid ? `uuid(${quote(colName)})` : `text(${quote(colName)})`;
+			const required = prop.validation?.required;
+			const refOptions = `{ onDelete: "${required ? "cascade" : "set null"}" }`;
+			columnDefinition = `${baseColumn}.references(() => ${member(targetTableVar, targetIdField)}, ${refOptions})`;
+			if (required) columnDefinition += ".notNull()";
+			return `    ${propKey(propName)}: ${columnDefinition}`;
+		}
+		default: throw new Error(`No Postgres column mapping for property '${propName}' of type '${prop.type}' in collection '${collection.slug}'. Add a case to \`getDrizzleColumn\` (and to \`getSqlColumnType\`, which must agree).`);
+	}
+	if (prop.validation?.required) columnDefinition += ".notNull()";
+	return `    ${propKey(propName)}: ${columnDefinition}`;
+};
+/**
+* Wraps a compiled SQL clause in a Drizzle `sql\`...\`` template literal.
+*
+* The clause is SQL being written into a TypeScript file, so it has to survive
+* being read back as a template literal. Three characters do not:
+*
+* - `` ` `` closes the template early, and the rest of the clause becomes code.
+* - `${` opens an interpolation — the file stops compiling, or worse, compiles
+*   against whatever identifier happens to be in scope.
+* - `\` is an escape, and Drizzle's `sql` tag reads the *cooked* strings, not
+*   `.raw`. So a policy written as `email ~ '^admin\.user@corp\.com$'` reaches
+*   the database as `^admin.user@corp.com$`, where every `\.` now matches any
+*   character. A `USING` clause is a security boundary and that one silently
+*   widened it — the SQL file emitted by the DDL generator kept the backslashes
+*   while this path dropped them, so the two disagreed about who could read the
+*   table.
+*
+* Escaping here rather than in the compiler: the clause is correct SQL, and it
+* is only this destination that has an opinion about backslashes.
+*/
+var wrapSql = (clause) => `sql\`${clause.replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\$\{/g, "\\${")}\``;
+var generatePolicyCode = (collection, rule, index, resolveCollection) => {
+	const tableName = getTableName(collection);
+	const ops = rule.operations && rule.operations.length > 0 ? rule.operations : [rule.operation ?? "all"];
+	const policyNames = getPolicyNamesForRule(rule, tableName);
+	return ops.map((op, opIdx) => {
+		return generateSinglePolicyCode(collection, rule, op, policyNames[opIdx], resolveCollection);
+	}).join("");
+};
+/**
+* Generates a single pgPolicy() call for one specific operation.
+*/
+var generateSinglePolicyCode = (collection, rule, operation, policyName, resolveCollection) => {
+	const mode = rule.mode ?? "permissive";
+	const needsUsing = operation !== "insert";
+	const needsWithCheck = operation !== "select" && operation !== "delete";
+	const { usingExpr, withCheckExpr } = securityRuleToConditions(rule);
+	let usingClause = needsUsing && usingExpr ? wrapSql(policyToPostgres(usingExpr, collection, { resolveCollection })) : null;
+	let withCheckClause = needsWithCheck && withCheckExpr ? wrapSql(policyToPostgres(withCheckExpr, collection, { resolveCollection })) : null;
+	if (!usingClause && needsUsing) usingClause = "sql`false`";
+	if (!withCheckClause && needsWithCheck) withCheckClause = "sql`false`";
+	const parts = [];
+	parts.push(`as: "${mode}"`);
+	parts.push(`for: "${operation}"`);
+	const toRoles = rule.pgRoles ? [...rule.pgRoles].sort() : ["public"];
+	parts.push(`to: [${toRoles.map((r) => `"${r}"`).join(", ")}]`);
+	if (usingClause) parts.push(`using: ${usingClause}`);
+	if (withCheckClause) parts.push(`withCheck: ${withCheckClause}`);
+	return `    pgPolicy(${quote(policyName)}, { ${parts.join(", ")} }),\n`;
+};
+/**
+* Computes a deterministic shared relation name for Drizzle.
+*
+* Drizzle requires both sides of a relation (owning + inverse) to use the
+* exact same `relationName` string so it can pair them. Each collection
+* definition may use a different local `relationName`, so we need a canonical
+* form that both sides can independently compute.
+*
+* Strategy: `{owningTable}_{foreignKey}`
+*   - owning  side → `{thisTable}_{localKey}`           e.g. "jobs_company_id"
+*   - inverse side → `{targetTable}_{foreignKeyOnTarget}` e.g. "jobs_company_id"
+*
+* For M2M with junction tables the owning relation name is already shared via
+* the junction table wiring, so we keep it as-is.
+*
+* Falls back to the local relation name when the counterpart can't be resolved.
+*/
+var computeSharedRelationName = (rel, sourceCollection, _collections) => {
+	const fallback = rel.relationName ?? toSnakeCase(rel.target().slug);
+	if (rel.kind === "belongsTo") {
+		const normalisedKey = resolvePropertyKeyForColumn(sourceCollection, rel.localKey);
+		return `${getTableName(sourceCollection)}_${normalisedKey}`;
+	}
+	if (rel.kind === "hasMany" || rel.kind === "hasOne") try {
+		const targetCollection = rel.target();
+		const normalisedFK = resolvePropertyKeyForColumn(targetCollection, rel.foreignKeyOnTarget);
+		return `${getTableName(targetCollection)}_${normalisedFK}`;
+	} catch {
+		return fallback;
+	}
+	return fallback;
+};
+var generateSchema = async (allCollections, stripPolicies = false) => {
+	const collections = sortCollectionsBySlug(relationalCollections(allCollections));
+	let schemaContent = "// This file is auto-generated by the Rebase Drizzle generator. Do not edit manually.\n\n";
+	const hasUuid = collections.some((c) => c.properties && Object.values(c.properties).some((p) => p.type === "string" && (p.autoValue === "uuid" || p.isId === "uuid")));
+	const hasVector = collections.some((c) => c.properties && Object.values(c.properties).some((p) => p.type === "vector"));
+	const hasBinary = collections.some((c) => c.properties && Object.values(c.properties).some((p) => p.type === "binary"));
+	const hasSearch = collections.some((c) => buildSearchColumnSpec(c) !== void 0);
+	const pgCoreImports = [
+		"primaryKey",
+		"pgTable",
+		"integer",
+		"varchar",
+		"text",
+		"char",
+		"boolean",
+		"timestamp",
+		"date",
+		"time",
+		"jsonb",
+		"json",
+		"pgEnum",
+		"numeric",
+		"real",
+		"doublePrecision",
+		"bigint",
+		"serial",
+		"bigserial",
+		"pgPolicy"
+	];
+	if (hasUuid) pgCoreImports.push("uuid");
+	if (hasVector) pgCoreImports.push("vector");
+	if (hasBinary || hasSearch) pgCoreImports.push("customType");
+	const uniqueSchemas = Array.from(new Set(collections.map((c) => isPostgresCollectionConfig(c) ? c.schema : void 0).filter(Boolean)));
+	if (uniqueSchemas.length > 0) pgCoreImports.push("pgSchema");
+	schemaContent += `import { ${pgCoreImports.join(", ")} } from 'drizzle-orm/pg-core';\n`;
+	schemaContent += "import { relations as drizzleRelations, sql } from 'drizzle-orm';\n\n";
+	uniqueSchemas.forEach((schema) => {
+		schemaContent += `export const ${schema}Schema = pgSchema("${schema}");\n`;
+	});
+	if (uniqueSchemas.length > 0) schemaContent += "\n";
+	const exportedTableVars = [];
+	const exportedEnumVars = [];
+	const exportedRelationVars = [];
+	const allTablesToGenerate = /* @__PURE__ */ new Map();
+	collections.forEach((collection) => {
+		const collectionPath = getTableName(collection);
+		Object.entries(collection.properties ?? {}).forEach(([propName, prop]) => {
+			if ("enum" in prop && (prop.type === "string" || prop.type === "number") && prop.enum) {
+				const enumVarName = getEnumVarName(collectionPath, propName);
+				const enumDbName = `${collectionPath}_${resolveColumnName(propName, prop)}`;
+				const values = Array.isArray(prop.enum) ? prop.enum.map((v) => String(typeof v === "object" && v !== null && "id" in v ? v.id : v)) : Object.keys(prop.enum);
+				if (values.length > 0) {
+					schemaContent += `export const ${enumVarName} = pgEnum(${quote(enumDbName)}, [${values.map((v) => quote(v)).join(", ")}]);\n`;
+					if (!exportedEnumVars.includes(enumVarName)) exportedEnumVars.push(enumVarName);
+				}
+			}
+		});
+	});
+	schemaContent += "\n";
+	const junctionSpecs = resolveJunctionSpecs(collections);
+	for (const collection of collections) {
+		const tableName = getTableName(collection);
+		if (tableName) allTablesToGenerate.set(tableName, { collection });
+		const resolvedRelations = resolveCollectionRelations(collection);
+		for (const relation of Object.values(resolvedRelations)) if (isManyToMany(relation)) {
+			const junctionTableName = relation.through.table;
+			if (!allTablesToGenerate.has(junctionTableName)) allTablesToGenerate.set(junctionTableName, {
+				collection: {
+					table: junctionTableName,
+					properties: {}
+				},
+				isJunction: true,
+				relation,
+				sourceCollection: collection
+			});
+		}
+	}
+	for (const [tableName, { collection, isJunction, relation, sourceCollection }] of allTablesToGenerate.entries()) {
+		const tableVarName = getTableVarName(tableName);
+		if (isJunction && relation && sourceCollection && isManyToMany(relation)) {
+			const targetCollection = relation.target();
+			const tableCreator = "pgTable";
+			const baseTableName = tableName.includes(".") ? tableName.split(".").pop() : tableName;
+			const { sourceColumn, targetColumn } = relation.through;
+			const refOptions = `{ onDelete: \"${relation.onDelete ?? "cascade"}\" }`;
+			const sourceColType = isNumericId(sourceCollection) ? "integer" : getPrimaryKeyProp(sourceCollection).isUuid ? "uuid" : "text";
+			const targetColType = isNumericId(targetCollection) ? "integer" : getPrimaryKeyProp(targetCollection).isUuid ? "uuid" : "text";
+			const sourceId = getPrimaryKeyName(sourceCollection);
+			const targetId = getPrimaryKeyName(targetCollection);
+			schemaContent += `export const ${tableVarName} = ${tableCreator}(\"${baseTableName}\", {\n`;
+			schemaContent += `    ${propKey(sourceColumn)}: ${sourceColType}(${quote(sourceColumn)}).notNull().references(() => ${member(getTableVarName(getTableName(sourceCollection)), sourceId)}, ${refOptions}),\n`;
+			schemaContent += `    ${propKey(targetColumn)}: ${targetColType}(${quote(targetColumn)}).notNull().references(() => ${member(getTableVarName(getTableName(targetCollection)), targetId)}, ${refOptions}),\n`;
+			schemaContent += "}, (table) => ([\n";
+			schemaContent += `    primaryKey({ columns: [${member("table", sourceColumn)}, ${member("table", targetColumn)}] }),\n`;
+			const junctionSpec = junctionSpecs.get(baseTableName);
+			if (!stripPolicies && junctionSpec) {
+				const junctionCollection = getJunctionCollectionConfig(junctionSpec);
+				const resolveCollection = (slug) => collections.find((c) => c.slug === slug || getTableName(c) === slug);
+				getJunctionSecurityRules(junctionSpec).forEach((rule, idx) => {
+					schemaContent += generatePolicyCode(junctionCollection, rule, idx, resolveCollection);
+				});
+			}
+			schemaContent += "])).enableRLS();\n\n";
+		} else if (!isJunction) {
+			const schema = isPostgresCollectionConfig(collection) ? collection.schema : void 0;
+			const tableCreator = schema ? `${schema}Schema.table` : "pgTable";
+			const baseTableName = tableName.includes(".") ? tableName.split(".").pop() : tableName;
+			schemaContent += `export const ${tableVarName} = ${tableCreator}(\"${baseTableName}\", {\n`;
+			const columns = /* @__PURE__ */ new Set();
+			Object.entries(collection.properties ?? {}).forEach(([propName, prop]) => {
+				const columnString = getDrizzleColumn(propName, prop, collection, collections);
+				if (columnString) columns.add(columnString);
+			});
+			const searchSpec = buildSearchColumnSpec(collection);
+			if (searchSpec) {
+				columns.add(`    ${propKey(searchSpec.column)}: customType({ dataType() { return 'tsvector'; } })(${quote(searchSpec.column)}).generatedAlwaysAs(sql\`${searchSpec.expression}\`)`);
+				if (searchSpec.fuzzy) columns.add(`    ${propKey(searchSpec.fuzzy.column)}: text(${quote(searchSpec.fuzzy.column)}).generatedAlwaysAs(sql\`${searchSpec.fuzzy.expression}\`)`);
+			}
+			if (!Array.from(columns).some((col) => col.includes(".primaryKey()"))) columns.add("    id: text(\"id\").primaryKey()");
+			schemaContent += `${Array.from(columns).join(",\n")}`;
+			const securityRules = getEffectiveSecurityRules(collection);
+			if (!stripPolicies && securityRules.length > 0) {
+				schemaContent += "\n}, (table) => ([\n";
+				const resolveCollection = (slug) => collections.find((c) => c.slug === slug || getTableName(c) === slug);
+				securityRules.forEach((rule, idx) => {
+					schemaContent += generatePolicyCode(collection, rule, idx, resolveCollection);
+				});
+				schemaContent += "])).enableRLS();\n\n";
+			} else schemaContent += "\n}).enableRLS();\n\n";
+		}
+		if (!exportedTableVars.includes(tableVarName)) exportedTableVars.push(tableVarName);
+	}
+	for (const [tableName, { collection, isJunction }] of allTablesToGenerate.entries()) {
+		const tableVarName = getTableVarName(tableName);
+		const tableRelations = [];
+		if (isJunction) {
+			const relationInfo = Array.from(allTablesToGenerate.values()).find((v) => v.isJunction && getTableName(v.collection) === tableName);
+			if (relationInfo && relationInfo.relation && relationInfo.sourceCollection && isManyToMany(relationInfo.relation)) {
+				const { relation, sourceCollection } = relationInfo;
+				const targetCollection = relation.target();
+				const sourceTableVar = getTableVarName(getTableName(sourceCollection));
+				const targetTableVar = getTableVarName(getTableName(targetCollection));
+				const sourceId = getPrimaryKeyName(sourceCollection);
+				const targetId = getPrimaryKeyName(targetCollection);
+				if (!relation?.through) throw new Error("Internal, the relation should have a through property. Relations passed to this script should sanitized first with sanitizeRelation().");
+				const owningRelationName = relation.relationName ?? toSnakeCase(getTableName(targetCollection));
+				let inverseRelationName = null;
+				try {
+					const targetRelations = resolveCollectionRelations(targetCollection);
+					for (const [, targetRel] of Object.entries(targetRelations)) if (targetRel.kind !== "belongsTo" && targetRel.cardinality === "many" && targetRel.relationName === owningRelationName) {
+						inverseRelationName = targetRel.relationName ?? null;
+						break;
+					}
+				} catch {}
+				tableRelations.push(`    ${quote(relation.through.sourceColumn)}: one(${sourceTableVar}, {\n        fields: [${member(tableVarName, relation.through.sourceColumn)}],\n        references: [${member(sourceTableVar, sourceId)}],\n        relationName: ${quote(owningRelationName)}\n    })`);
+				const targetRelationName = inverseRelationName ? inverseRelationName : `${tableName}_${relation.through.targetColumn}`;
+				tableRelations.push(`    ${quote(relation.through.targetColumn)}: one(${targetTableVar}, {\n        fields: [${member(tableVarName, relation.through.targetColumn)}],\n        references: [${member(targetTableVar, targetId)}],\n        relationName: ${quote(targetRelationName)}\n    })`);
+			}
+		} else {
+			const resolvedRelations = resolveCollectionRelations(collection);
+			const emittedRelationNames = /* @__PURE__ */ new Set();
+			for (const [relationKey, rel] of Object.entries(resolvedRelations)) try {
+				const target = rel.target();
+				const targetTableVar = getTableVarName(getTableName(target));
+				const drizzleRelationName = computeSharedRelationName(rel, collection, collections);
+				const deduplicationKey = `${drizzleRelationName}::${rel.kind}`;
+				if (emittedRelationNames.has(deduplicationKey)) continue;
+				emittedRelationNames.add(deduplicationKey);
+				switch (rel.kind) {
+					case "belongsTo": {
+						const localFieldKey = resolvePropertyKeyForColumn(collection, rel.localKey);
+						tableRelations.push(`    ${quote(relationKey)}: one(${targetTableVar}, {\n        fields: [${member(tableVarName, localFieldKey)}],\n        references: [${member(targetTableVar, getPrimaryKeyName(target))}],\n        relationName: ${quote(drizzleRelationName)}\n    })`);
+						break;
+					}
+					case "hasOne":
+						tableRelations.push(`    ${quote(relationKey)}: one(${targetTableVar}, {\n        relationName: ${quote(drizzleRelationName)}\n    })`);
+						break;
+					case "hasMany":
+						tableRelations.push(`    ${quote(relationKey)}: many(${targetTableVar}, { relationName: ${quote(drizzleRelationName)} })`);
+						break;
+					case "manyToMany": {
+						const junctionTableVar = getTableVarName(rel.through.table);
+						tableRelations.push(`    ${quote(relationKey)}: many(${junctionTableVar}, { relationName: ${quote(drizzleRelationName)} })`);
+						break;
+					}
+					case "via": break;
+				}
+			} catch (e) {
+				logger.warn(`Could not generate relation ${relationKey} for ${collection.name}`, { error: e });
+			}
+			for (const otherCollection of collections) {
+				if (otherCollection.slug === collection.slug) continue;
+				const otherRelations = resolveCollectionRelations(otherCollection);
+				for (const [otherKey, otherRel] of Object.entries(otherRelations)) if (hasForeignKeyOnTarget(otherRel)) try {
+					if (otherRel.target().slug === collection.slug) {
+						const drizzleRelationName = computeSharedRelationName(otherRel, otherCollection, collections);
+						const deduplicationKey = `${drizzleRelationName}::belongsTo`;
+						if (!emittedRelationNames.has(deduplicationKey)) {
+							const otherTableVar = getTableVarName(getTableName(otherCollection));
+							const drizzleFieldKey = resolvePropertyKeyForColumn(collection, otherRel.foreignKeyOnTarget);
+							const referencedKey = otherRel.sourceKey ? resolvePropertyKeyForColumn(otherCollection, otherRel.sourceKey) : getPrimaryKeyName(otherCollection);
+							const synthKey = `_synth_${otherTableVar}_${drizzleFieldKey}`;
+							tableRelations.push(`    ${quote(synthKey)}: one(${otherTableVar}, {\n        fields: [${member(tableVarName, drizzleFieldKey)}],\n        references: [${member(otherTableVar, referencedKey)}],\n        relationName: ${quote(drizzleRelationName)}\n    })`);
+							emittedRelationNames.add(deduplicationKey);
+						}
+					}
+				} catch (e) {}
+			}
+		}
+		if (tableRelations.length > 0) {
+			const relVarName = `${tableVarName}Relations`;
+			schemaContent += `export const ${relVarName} = drizzleRelations(${tableVarName}, ({ one, many }) => ({\n${tableRelations.join(",\n")}\n}));\n\n`;
+			if (!exportedRelationVars.includes(relVarName)) exportedRelationVars.push(relVarName);
+		}
+	}
+	const tablesExport = `export const tables = { ${exportedTableVars.join(", ")} };\n`;
+	const enumsExport = `export const enums = { ${exportedEnumVars.join(", ")} };\n`;
+	const relationsExport = `export const relations = { ${exportedRelationVars.join(", ")} };\n\n`;
+	schemaContent += tablesExport + enumsExport + relationsExport;
+	return schemaContent;
+};
+//#endregion
+export { getDrizzleColumn as n, generateSchema as t };
+
+//# sourceMappingURL=generate-drizzle-schema-logic-so2Z_lyC.js.map