@rebasepro/server-postgres 0.19.1 → 0.19.2-canary.g08eed46

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

@@ -1,528 +0,0 @@
-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