@apso/cli 0.4.2 → 0.6.0

package/dist/lib/types/auth.d.ts

@@ -0,0 +1,203 @@
+/**
+ * Supported authentication provider types
+ */
+export type AuthProviderType = "better-auth" | "custom-db-session" | "auth0" | "clerk" | "cognito" | "api-key";
+/**
+ * Base configuration common to all auth providers
+ */
+export interface BaseAuthConfig {
+    /**
+     * The authentication provider type
+     */
+    provider: AuthProviderType;
+}
+/**
+ * Configuration for DB-backed session providers (Better Auth, custom-db-session)
+ */
+export interface DbSessionAuthConfig extends BaseAuthConfig {
+    provider: "better-auth" | "custom-db-session";
+    /**
+     * Entity name for sessions. Default: "session"
+     */
+    sessionEntity?: string;
+    /**
+     * Entity name for users. Default: "User"
+     */
+    userEntity?: string;
+    /**
+     * Junction entity for user-organization mapping. Default: "AccountUser"
+     */
+    accountUserEntity?: string;
+    /**
+     * Cookie name prefix for session tokens. Default: service name
+     */
+    cookiePrefix?: string;
+    /**
+     * Field name on accountUserEntity for organization ID. Default: "organizationId"
+     */
+    organizationField?: string;
+    /**
+     * Field name on accountUserEntity for user's role. Default: "role"
+     */
+    roleField?: string;
+}
+/**
+ * JWT configuration for token-based providers
+ */
+export interface JwtConfig {
+    /**
+     * The JWT issuer URL (e.g., "https://your-tenant.auth0.com/")
+     */
+    issuer: string;
+    /**
+     * Expected audience for the JWT
+     */
+    audience: string;
+    /**
+     * JWKS URI for key rotation. If not provided, uses issuer + /.well-known/jwks.json
+     */
+    jwksUri?: string;
+    /**
+     * Algorithms to accept. Default: ["RS256"]
+     */
+    algorithms?: string[];
+}
+/**
+ * Claim mapping for JWT providers
+ */
+export interface JwtClaimsMapping {
+    /**
+     * Claim for user ID. Default: "sub"
+     */
+    userId?: string;
+    /**
+     * Claim for workspace/organization ID
+     */
+    workspaceId?: string;
+    /**
+     * Claim for organization ID (alias for workspaceId)
+     */
+    organizationId?: string;
+    /**
+     * Claim for user roles array
+     */
+    roles?: string;
+    /**
+     * Claim for user email
+     */
+    email?: string;
+}
+/**
+ * Configuration for JWT-based providers (Auth0, Cognito, Clerk)
+ */
+export interface JwtAuthConfig extends BaseAuthConfig {
+    provider: "auth0" | "clerk" | "cognito";
+    /**
+     * JWT verification configuration
+     */
+    jwt: JwtConfig;
+    /**
+     * Mapping of JWT claims to AuthContext fields
+     */
+    claims?: JwtClaimsMapping;
+    /**
+     * Optional: If you want to sync/verify users against a local User entity
+     */
+    userEntity?: string;
+}
+/**
+ * Configuration for API key authentication
+ */
+export interface ApiKeyAuthConfig extends BaseAuthConfig {
+    provider: "api-key";
+    /**
+     * Header name for API key. Default: "x-api-key"
+     */
+    apiKeyHeader?: string;
+    /**
+     * Entity name for API keys. Default: "ApiKey"
+     */
+    apiKeyEntity?: string;
+    /**
+     * Field name on apiKeyEntity for workspace/organization ID
+     */
+    workspaceField?: string;
+    /**
+     * Field name on apiKeyEntity for role/permissions
+     */
+    roleField?: string;
+}
+/**
+ * Union type of all auth configurations
+ */
+export type AuthConfig = DbSessionAuthConfig | JwtAuthConfig | ApiKeyAuthConfig;
+/**
+ * The normalized AuthContext that all providers produce.
+ * This is what scopeBy and RBAC consume.
+ */
+export interface AuthContext {
+    /**
+     * The authenticated user's ID
+     */
+    userId?: string;
+    /**
+     * The user's email (if available)
+     */
+    email?: string;
+    /**
+     * The workspace/tenant ID (generic term)
+     */
+    workspaceId?: string;
+    /**
+     * The organization ID (alias for workspaceId in multi-tenant contexts)
+     */
+    organizationId?: string;
+    /**
+     * Array of roles/permissions the user has
+     */
+    roles: string[];
+    /**
+     * For API key auth: the service/key identifier
+     */
+    serviceId?: string;
+    /**
+     * Raw user object (provider-specific, for advanced use cases)
+     */
+    user?: unknown;
+    /**
+     * Raw session object (provider-specific, for advanced use cases)
+     */
+    session?: unknown;
+}
+/**
+ * Default values for DB session auth configuration
+ */
+export declare const DB_SESSION_AUTH_DEFAULTS: Required<Omit<DbSessionAuthConfig, "provider" | "cookiePrefix">> & {
+    cookiePrefix?: string;
+};
+/**
+ * Default values for JWT auth configuration
+ */
+export declare const JWT_AUTH_DEFAULTS: Required<Pick<JwtAuthConfig, "claims">> & Partial<JwtConfig>;
+/**
+ * Default values for API key auth configuration
+ */
+export declare const API_KEY_AUTH_DEFAULTS: Required<Omit<ApiKeyAuthConfig, "provider" | "workspaceField" | "roleField">>;
+/**
+ * Type guard: Check if auth config is DB session based
+ * @param {AuthConfig} auth - The auth configuration to check
+ * @returns {boolean} True if the auth config is DB session based
+ */
+export declare function isDbSessionAuth(auth: AuthConfig): auth is DbSessionAuthConfig;
+/**
+ * Type guard: Check if auth config is JWT based
+ * @param {AuthConfig} auth - The auth configuration to check
+ * @returns {boolean} True if the auth config is JWT based
+ */
+export declare function isJwtAuth(auth: AuthConfig): auth is JwtAuthConfig;
+/**
+ * Type guard: Check if auth config is API key based
+ * @param {AuthConfig} auth - The auth configuration to check
+ * @returns {boolean} True if the auth config is API key based
+ */
+export declare function isApiKeyAuth(auth: AuthConfig): auth is ApiKeyAuthConfig;

package/dist/lib/types/auth.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isApiKeyAuth = exports.isJwtAuth = exports.isDbSessionAuth = exports.API_KEY_AUTH_DEFAULTS = exports.JWT_AUTH_DEFAULTS = exports.DB_SESSION_AUTH_DEFAULTS = void 0;
+/**
+ * Default values for DB session auth configuration
+ */
+exports.DB_SESSION_AUTH_DEFAULTS = {
+    sessionEntity: "session",
+    userEntity: "User",
+    accountUserEntity: "AccountUser",
+    organizationField: "organizationId",
+    roleField: "role",
+    cookiePrefix: undefined, // Will use service name if not specified
+};
+/**
+ * Default values for JWT auth configuration
+ */
+exports.JWT_AUTH_DEFAULTS = {
+    claims: {
+        userId: "sub",
+        email: "email",
+        roles: "roles",
+    },
+};
+/**
+ * Default values for API key auth configuration
+ */
+exports.API_KEY_AUTH_DEFAULTS = {
+    apiKeyHeader: "x-api-key",
+    apiKeyEntity: "ApiKey",
+};
+/**
+ * Type guard: Check if auth config is DB session based
+ * @param {AuthConfig} auth - The auth configuration to check
+ * @returns {boolean} True if the auth config is DB session based
+ */
+function isDbSessionAuth(auth) {
+    return auth.provider === "better-auth" || auth.provider === "custom-db-session";
+}
+exports.isDbSessionAuth = isDbSessionAuth;
+/**
+ * Type guard: Check if auth config is JWT based
+ * @param {AuthConfig} auth - The auth configuration to check
+ * @returns {boolean} True if the auth config is JWT based
+ */
+function isJwtAuth(auth) {
+    return (auth.provider === "auth0" ||
+        auth.provider === "clerk" ||
+        auth.provider === "cognito");
+}
+exports.isJwtAuth = isJwtAuth;
+/**
+ * Type guard: Check if auth config is API key based
+ * @param {AuthConfig} auth - The auth configuration to check
+ * @returns {boolean} True if the auth config is API key based
+ */
+function isApiKeyAuth(auth) {
+    return auth.provider === "api-key";
+}
+exports.isApiKeyAuth = isApiKeyAuth;

package/dist/lib/types/entity.d.ts

@@ -2,13 +2,48 @@ import { Unique } from "./constraints";
 import { Field } from "./field";
 import { Index } from "./indices";
 import { Association } from "./relationship";
+/**
+ * Operations that can have scope enforcement applied
+ */
+export type ScopeOperation = "find" | "get" | "create" | "update" | "delete";
+/**
+ * Configuration options for scope enforcement behavior
+ */
+export interface ScopeOptions {
+    /**
+     * If true (default), scope fields are automatically injected from
+     * the request context on create when not provided.
+     */
+    injectOnCreate?: boolean;
+    /**
+     * Which operations should enforce scope. Defaults to all operations.
+     */
+    enforceOn?: ScopeOperation[];
+    /**
+     * Roles allowed to bypass scope enforcement (e.g., 'system_admin').
+     */
+    bypassRoles?: string[];
+}
 export interface Entity {
     name: string;
     created_at?: boolean;
     updated_at?: boolean;
-    primaryKeyType?: 'serial' | 'uuid';
+    primaryKeyType?: "serial" | "uuid";
     fields?: Field[];
     indexes?: Index[];
     uniques?: Unique[];
+    /**
+     * Fields or paths that define the authorization scope for this entity.
+     * Can be a single field name (e.g., 'workspaceId') or an array of fields/paths
+     * (e.g., ['workspaceId', 'serviceId'] or ['task.workspaceId']).
+     *
+     * - Direct fields: 'workspaceId' - enforces WHERE workspaceId = ctx.workspaceId
+     * - Nested paths: 'task.workspaceId' - joins to related entity and enforces scope
+     */
+    scopeBy?: string | string[];
+    /**
+     * Optional configuration for how scope enforcement should behave.
+     */
+    scopeOptions?: ScopeOptions;
     associations?: Association[];
 }

package/dist/lib/types/index.d.ts

@@ -1,5 +1,6 @@
-export { Entity } from "./entity";
+export { Entity, ScopeOptions, ScopeOperation } from "./entity";
 export { FieldType, Field, ComputedField } from "./field";
 export { Index } from "./indices";
 export { JSONValue } from "./json";
 export { RelationshipType, Association, ApsorcRelationship, Relationship, RelationshipForTemplate, RelationshipMap, } from "./relationship";
+export { AuthProviderType, BaseAuthConfig, DbSessionAuthConfig, JwtConfig, JwtClaimsMapping, JwtAuthConfig, ApiKeyAuthConfig, AuthConfig, AuthContext, DB_SESSION_AUTH_DEFAULTS, JWT_AUTH_DEFAULTS, API_KEY_AUTH_DEFAULTS, isDbSessionAuth, isJwtAuth, isApiKeyAuth, } from "./auth";

package/dist/lib/types/index.js

@@ -1,2 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.isApiKeyAuth = exports.isJwtAuth = exports.isDbSessionAuth = exports.API_KEY_AUTH_DEFAULTS = exports.JWT_AUTH_DEFAULTS = exports.DB_SESSION_AUTH_DEFAULTS = void 0;
+var auth_1 = require("./auth");
+Object.defineProperty(exports, "DB_SESSION_AUTH_DEFAULTS", { enumerable: true, get: function () { return auth_1.DB_SESSION_AUTH_DEFAULTS; } });
+Object.defineProperty(exports, "JWT_AUTH_DEFAULTS", { enumerable: true, get: function () { return auth_1.JWT_AUTH_DEFAULTS; } });
+Object.defineProperty(exports, "API_KEY_AUTH_DEFAULTS", { enumerable: true, get: function () { return auth_1.API_KEY_AUTH_DEFAULTS; } });
+Object.defineProperty(exports, "isDbSessionAuth", { enumerable: true, get: function () { return auth_1.isDbSessionAuth; } });
+Object.defineProperty(exports, "isJwtAuth", { enumerable: true, get: function () { return auth_1.isJwtAuth; } });
+Object.defineProperty(exports, "isApiKeyAuth", { enumerable: true, get: function () { return auth_1.isApiKeyAuth; } });

package/dist/lib/types/relationship.d.ts

@@ -36,7 +36,7 @@ export interface RelationshipForTemplate extends Relationship {
     joinTable: boolean;
     biDirectional: boolean;
     inversePropertyName?: string;
-    referencedEntityPrimaryKeyType?: 'serial' | 'uuid';
+    referencedEntityPrimaryKeyType?: "serial" | "uuid";
 }
 export type RelationshipMap = {
     [key: string]: Relationship[];

package/dist/lib/utils/casing.js

@@ -2,16 +2,16 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.pascalCase = exports.snakeCase = exports.camelCase = void 0;
 function camelCase(str) {
-    return str
+    return (str
         // Insert a space before all caps that are followed by lower case (for PascalCase)
-        .replace(/([\da-z])([A-Z])/g, '$1 $2')
+        .replace(/([\da-z])([A-Z])/g, "$1 $2")
         // Replace all separators with spaces
-        .replace(/[ _-]+/g, ' ')
+        .replace(/[ _-]+/g, " ")
         // Lowercase the string, then uppercase the first letter of each word (except the first)
         .toLowerCase()
-        .replace(/ (\w)/g, (_, c) => c ? c.toUpperCase() : '')
+        .replace(/ (\w)/g, (_, c) => (c ? c.toUpperCase() : ""))
         // Remove spaces
-        .replace(/ /g, '');
+        .replace(/ /g, ""));
 }
 exports.camelCase = camelCase;
 const snakeCase = (str) => str[0].toLowerCase() +

package/dist/lib/utils/field.js

@@ -102,7 +102,8 @@ const validateDecimalField = (field) => {
         return;
     }
     // Validate precision
-    if (field.precision !== undefined && (field.precision < 1 || field.precision > 131072)) {
+    if (field.precision !== undefined &&
+        (field.precision < 1 || field.precision > 131072)) {
         throw new Error(`${field.name}: Invalid precision value ${field.precision}. Must be between 1 and 131072.`);
     }
     // Validate scale

package/dist/lib/utils/file-system.js

@@ -54,7 +54,7 @@ function withGeneratedMeta(data) {
     return {
         ...data,
         generatedAt: new Date().toISOString(),
-        generatedBy: process.env.USER || process.env.USERNAME || 'unknown',
+        generatedBy: process.env.USER || process.env.USERNAME || "unknown",
     };
 }
 exports.withGeneratedMeta = withGeneratedMeta;

package/dist/lib/utils/relationships/parse-v1.js

@@ -79,7 +79,8 @@ const parseV1Relationships = (entities) => {
     for (const apsorcRelationship of apsorcRelationships) {
         const parsedResult = (0, parse_1.parseRelationship)(apsorcRelationship, apsorcRelationships);
         for (const key of Object.keys(parsedResult)) {
-            if (parsedResult[key] && parsedResult[key].length > 0) { // Ensure non-empty result
+            if (parsedResult[key] && parsedResult[key].length > 0) {
+                // Ensure non-empty result
                 relationshipMap[key] = [
                     ...(relationshipMap[key] || []),
                     ...parsedResult[key],

package/dist/lib/utils/relationships/parse.js

@@ -13,8 +13,27 @@ const casing_1 = require("../casing");
  */
 const parseOneToMany = (relationship) => {
     return {
-        [relationship.from]: [{ name: relationship.to, type: "OneToMany", biDirectional: true, referenceName: relationship.to_name || relationship.to, inverseReferenceName: relationship.from }],
-        [relationship.to]: [{ name: relationship.from, type: "ManyToOne", nullable: relationship.nullable || false, biDirectional: true, index: relationship.index || false, cascadeDelete: relationship.cascadeDelete || false, referenceName: relationship.from, inverseReferenceName: relationship.to_name || relationship.to }],
+        [relationship.from]: [
+            {
+                name: relationship.to,
+                type: "OneToMany",
+                biDirectional: true,
+                referenceName: relationship.to_name || relationship.to,
+                inverseReferenceName: relationship.from,
+            },
+        ],
+        [relationship.to]: [
+            {
+                name: relationship.from,
+                type: "ManyToOne",
+                nullable: relationship.nullable || false,
+                biDirectional: true,
+                index: relationship.index || false,
+                cascadeDelete: relationship.cascadeDelete || false,
+                referenceName: relationship.from,
+                inverseReferenceName: relationship.to_name || relationship.to,
+            },
+        ],
     };
 };
 exports.parseOneToMany = parseOneToMany;
@@ -51,9 +70,9 @@ exports.parseManytoOne = parseManytoOne;
  */
 const parseManyToMany = (relationship, allRelationships) => {
     // Find the inverse relationship definition (if exists)
-    const inverseDefinition = allRelationships.find(def => def.from === relationship.to &&
+    const inverseDefinition = allRelationships.find((def) => def.from === relationship.to &&
         def.to === relationship.from &&
-        def.type === 'ManyToMany');
+        def.type === "ManyToMany");
     // Determine if the relationship should be treated as bidirectional
     const isEffectivelyBiDirectional = Boolean(relationship.bi_directional || (inverseDefinition === null || inverseDefinition === void 0 ? void 0 : inverseDefinition.bi_directional));
     // For self-referencing relationships, find the matching inverse by to_name
@@ -61,19 +80,22 @@ const parseManyToMany = (relationship, allRelationships) => {
     let selfRefInverse = null;
     if (isSelfReferencing && relationship.bi_directional) {
         // Find the other relationship that completes the pair
-        selfRefInverse = allRelationships.find(def => def.from === relationship.from &&
+        selfRefInverse = allRelationships.find((def) => def.from === relationship.from &&
             def.to === relationship.to &&
-            def.type === 'ManyToMany' &&
+            def.type === "ManyToMany" &&
             def.bi_directional &&
             def.to_name !== relationship.to_name);
     }
-    let isOwningSide = relationship.joinTableName || relationship.joinColumnName || relationship.inverseJoinColumnName
+    let isOwningSide = relationship.joinTableName ||
+        relationship.joinColumnName ||
+        relationship.inverseJoinColumnName
         ? true
         : undefined;
     if (isOwningSide === undefined && inverseDefinition) {
         // If current doesn't have details, check if inverse does
-        isOwningSide =
-            !(inverseDefinition.joinTableName || inverseDefinition.joinColumnName || inverseDefinition.inverseJoinColumnName);
+        isOwningSide = !(inverseDefinition.joinTableName ||
+            inverseDefinition.joinColumnName ||
+            inverseDefinition.inverseJoinColumnName);
     }
     if (isOwningSide === undefined) {
         // If neither has details, default to the current definition being the owner
@@ -113,10 +135,18 @@ const parseManyToMany = (relationship, allRelationships) => {
         referenceName: fromSideRefName,
         join: isOwningSide,
         biDirectional: isEffectivelyBiDirectional,
-        joinTableName: isOwningSide ? (relationship.joinTableName || undefined) : undefined,
-        joinColumnName: isOwningSide ? (relationship.joinColumnName || undefined) : undefined,
-        inverseJoinColumnName: isOwningSide ? (relationship.inverseJoinColumnName || undefined) : undefined,
-        inverseReferenceName: isEffectivelyBiDirectional ? toSideRefName : undefined, // Only add inverse name if bidirectional
+        joinTableName: isOwningSide
+            ? relationship.joinTableName || undefined
+            : undefined,
+        joinColumnName: isOwningSide
+            ? relationship.joinColumnName || undefined
+            : undefined,
+        inverseJoinColumnName: isOwningSide
+            ? relationship.inverseJoinColumnName || undefined
+            : undefined,
+        inverseReferenceName: isEffectivelyBiDirectional
+            ? toSideRefName
+            : undefined, // Only add inverse name if bidirectional
     };
     const response = {
         [relationship.from]: [fromSideRelationship],
@@ -135,14 +165,20 @@ const parseManyToMany = (relationship, allRelationships) => {
             join: isInverseOwningSide,
             biDirectional: true,
             // Add join details ONLY if the inverse side IS the owner
-            joinTableName: isInverseOwningSide ? ((inverseDefinition === null || inverseDefinition === void 0 ? void 0 : inverseDefinition.joinTableName) || undefined) : undefined,
-            joinColumnName: isInverseOwningSide ? ((inverseDefinition === null || inverseDefinition === void 0 ? void 0 : inverseDefinition.joinColumnName) || undefined) : undefined,
-            inverseJoinColumnName: isInverseOwningSide ? ((inverseDefinition === null || inverseDefinition === void 0 ? void 0 : inverseDefinition.inverseJoinColumnName) || undefined) : undefined,
+            joinTableName: isInverseOwningSide
+                ? (inverseDefinition === null || inverseDefinition === void 0 ? void 0 : inverseDefinition.joinTableName) || undefined
+                : undefined,
+            joinColumnName: isInverseOwningSide
+                ? (inverseDefinition === null || inverseDefinition === void 0 ? void 0 : inverseDefinition.joinColumnName) || undefined
+                : undefined,
+            inverseJoinColumnName: isInverseOwningSide
+                ? (inverseDefinition === null || inverseDefinition === void 0 ? void 0 : inverseDefinition.inverseJoinColumnName) || undefined
+                : undefined,
             inverseReferenceName: fromSideRefName, // The reference name of the other side
         };
         response[relationship.to] = [
             ...(response[relationship.to] || []),
-            toSideRelationship
+            toSideRelationship,
         ];
     }
     return response;
@@ -205,13 +241,40 @@ const parseRelationship = (relationship, allRelationships) => {
             const fromSideRefName = relationship.to_name || relationship.to;
             const toSideRefName = relationship.from;
             return {
-                [relationship.from]: [{ name: relationship.to, type: "OneToMany", biDirectional: true, referenceName: fromSideRefName, inverseReferenceName: toSideRefName }],
-                [relationship.to]: [{ name: relationship.from, type: "ManyToOne", nullable: relationship.nullable || false, biDirectional: true, index: relationship.index || false, cascadeDelete: relationship.cascadeDelete || false, referenceName: toSideRefName, inverseReferenceName: fromSideRefName }],
+                [relationship.from]: [
+                    {
+                        name: relationship.to,
+                        type: "OneToMany",
+                        biDirectional: true,
+                        referenceName: fromSideRefName,
+                        inverseReferenceName: toSideRefName,
+                    },
+                ],
+                [relationship.to]: [
+                    {
+                        name: relationship.from,
+                        type: "ManyToOne",
+                        nullable: relationship.nullable || false,
+                        biDirectional: true,
+                        index: relationship.index || false,
+                        cascadeDelete: relationship.cascadeDelete || false,
+                        referenceName: toSideRefName,
+                        inverseReferenceName: fromSideRefName,
+                    },
+                ],
             };
         }
         case "ManyToOne":
             return {
-                [relationship.from]: [{ name: relationship.to, type: "ManyToOne", referenceName: relationship.to_name || relationship.to, nullable: relationship.nullable || false, index: relationship.index || false }],
+                [relationship.from]: [
+                    {
+                        name: relationship.to,
+                        type: "ManyToOne",
+                        referenceName: relationship.to_name || relationship.to,
+                        nullable: relationship.nullable || false,
+                        index: relationship.index || false,
+                    },
+                ],
             };
         case "OneToOne": {
             const inverseOnetoOneDef = allRelationships.find((def) => def.from === relationship.to &&
@@ -243,7 +306,7 @@ const parseRelationship = (relationship, allRelationships) => {
                         biDirectional: true,
                         join: !(fromRel.join || false),
                         referenceName: relationship.from,
-                        inverseReferenceName: fromRel.referenceName || undefined // Reference the 'from' side's name, default to undefined if null
+                        inverseReferenceName: fromRel.referenceName || undefined, // Reference the 'from' side's name, default to undefined if null
                     };
                     responseMap[relationship.to] = [
                         ...(responseMap[relationship.to] || []),
@@ -300,7 +363,7 @@ exports.getRelationshipIdField = getRelationshipIdField;
  */
 const calculateInversePropertyName = (relationship, entityName, relationshipName, needsPluralInverse) => {
     const isSelfReferencing = relationship.name === entityName;
-    if (isSelfReferencing && relationship.type === 'ManyToMany') {
+    if (isSelfReferencing && relationship.type === "ManyToMany") {
         if (relationship.inverseReferenceName) {
             return (0, casing_1.camelCase)(relationship.inverseReferenceName);
         }
@@ -314,9 +377,25 @@ const calculateInversePropertyName = (relationship, entityName, relationshipName
         }
         // Check for special plural terms
         const specialPlurals = [
-            'children', 'people', 'men', 'women', 'mice', 'geese', 'teeth', 'feet',
-            'oxen', 'cacti', 'indices', 'vertices', 'analyses', 'crises', 'diagnoses',
-            'media', 'criteria', 'data', 'parents'
+            "children",
+            "people",
+            "men",
+            "women",
+            "mice",
+            "geese",
+            "teeth",
+            "feet",
+            "oxen",
+            "cacti",
+            "indices",
+            "vertices",
+            "analyses",
+            "crises",
+            "diagnoses",
+            "media",
+            "criteria",
+            "data",
+            "parents",
         ];
         if (specialPlurals.includes(relationship.inverseReferenceName)) {
             return relationship.inverseReferenceName;
@@ -341,7 +420,7 @@ const getRelationshipForTemplate = (entityName, relationships, entities) => {
     // Create entity map for looking up primary key types
     const entityMap = new Map();
     if (entities) {
-        entities.forEach(entity => {
+        entities.forEach((entity) => {
             entityMap.set(entity.name, entity);
         });
     }
@@ -353,7 +432,8 @@ const getRelationshipForTemplate = (entityName, relationships, entities) => {
         const refName = relationship.referenceName || "default";
         const key = `${name}:${refName}`;
         // Use the relationship with join=true if there are duplicates (this is the owning side)
-        if (!processedRefs.has(key) || (relationship.join && !((_a = processedRefs.get(key)) === null || _a === void 0 ? void 0 : _a.join))) {
+        if (!processedRefs.has(key) ||
+            (relationship.join && !((_a = processedRefs.get(key)) === null || _a === void 0 ? void 0 : _a.join))) {
             processedRefs.set(key, relationship);
         }
     });
@@ -361,7 +441,7 @@ const getRelationshipForTemplate = (entityName, relationships, entities) => {
     return [...processedRefs.values()].map((relationship) => {
         const thisReferenceName = relationship.referenceName;
         const relationshipName = (0, casing_1.camelCase)(thisReferenceName || relationship.name);
-        const needsPluralInverse = relationship.type === 'ManyToOne' || relationship.type === 'ManyToMany';
+        const needsPluralInverse = relationship.type === "ManyToOne" || relationship.type === "ManyToMany";
         // DEBUG LOGGING
         // if (process.env.DEBUG) {
         //   console.log(
@@ -373,13 +453,16 @@ const getRelationshipForTemplate = (entityName, relationships, entities) => {
         //   );
         // }
         const inverseSidePropertyName = calculateInversePropertyName(relationship, entityName, relationshipName, needsPluralInverse);
-        if (relationship.biDirectional && !relationship.inverseReferenceName &&
-            (relationship.type === 'ManyToMany' || relationship.type === 'OneToMany' || relationship.type === 'OneToOne')) {
+        if (relationship.biDirectional &&
+            !relationship.inverseReferenceName &&
+            (relationship.type === "ManyToMany" ||
+                relationship.type === "OneToMany" ||
+                relationship.type === "OneToOne")) {
             console.info(`[APSO INFO] Using default property name '${inverseSidePropertyName}' for ${relationship.name}->${entityName}. To customize, add 'to_name' in your relationship definition.`);
         }
         // Look up the referenced entity's primary key type
         const referencedEntity = entityMap.get(relationship.name);
-        const referencedEntityPrimaryKeyType = (referencedEntity === null || referencedEntity === void 0 ? void 0 : referencedEntity.primaryKeyType) || 'serial'; // Default to 'serial' if not specified
+        const referencedEntityPrimaryKeyType = (referencedEntity === null || referencedEntity === void 0 ? void 0 : referencedEntity.primaryKeyType) || "serial"; // Default to 'serial' if not specified
         return {
             ...relationship,
             relationshipName,
@@ -477,7 +560,9 @@ function* generateNestedRelationships(entityName, relationshipMap, maxDepth = 4,
 exports.generateNestedRelationships = generateNestedRelationships;
 // In-memory collector
 function getNestedRelationships(entityName, relationshipMap, maxDepth) {
-    return [...generateNestedRelationships(entityName, relationshipMap, maxDepth)];
+    return [
+        ...generateNestedRelationships(entityName, relationshipMap, maxDepth),
+    ];
 }
 exports.getNestedRelationships = getNestedRelationships;
 // Streaming function