from cube import config

config.schema_path = 'my-data-model'

module.exports = {
  schemaPath: 'my-data-model'
}

from cube import config

@config('context_to_app_id')
def context_to_app_id(ctx: dict) -> str:
  return f"CUBE_APP_{ctx['securityContext']['tenant_id']}"

module.exports = {
  contextToAppId: ({ securityContext }) => {
    return `CUBE_APP_${securityContext.tenant_id}`
  }
}

from cube import config, file_repository

@config('repository_factory')
def repository_factory(ctx: dict) -> list[dict]:
  return file_repository(f"model/{ctx['securityContext']['tenant_id']}")

const { FileRepository } = require("@cubejs-backend/server-core")

module.exports = {
  repositoryFactory: ({ securityContext }) => {
    return new FileRepository(`model/${securityContext.tenant_id}`)
  }
}

from cube import config, file_repository

@config('repository_factory')
def repository_factory(ctx: dict) -> list[dict]:
  context = ctx['securityContext']

  return [
    {
      'fileName': 'file.js',
      'content': 'contents of file'
    }
  ]

module.exports = {
  repositoryFactory: ({ securityContext }) => {
    return {
      dataSchemaFiles: async () =>
        await Promise.resolve([
          {
            fileName: 'file.js',
            content: 'contents of file'
          }
        ])
    }
  }
}

from cube import config
import random

@config('schema_version')
def schema_version(ctx: dict) -> str:
  # Don't do this!
  # Data model would be recompiled on each request
  context = ctx['securityContext']

  return random.random()

module.exports = {
  schemaVersion: ({ securityContext }) => {
    // Don't do this!
    // Data model would be recompiled on each request
    return Math.random()
  }
}

from cube import config

config.compiler_cache_size = 100

module.exports = {
  compilerCacheSize: 100
}

from cube import config

config.max_compiler_cache_keep_alive = 10000

module.exports = {
  maxCompilerCacheKeepAlive: 10000
}

from cube import config

config.update_compiler_cache_keep_alive = True

module.exports = {
  updateCompilerCacheKeepAlive: true
}

from cube import config

config.allow_js_duplicate_props_in_schema = True

module.exports = {
  allowJsDuplicatePropsInSchema: true
}

from cube import config

config.cache_and_queue_driver = 'cubestore'

module.exports = {
  cacheAndQueueDriver: 'cubestore'
}

from cube import config

@config('context_to_app_id')
def context_to_app_id(ctx: dict) -> str:
  return f"CUBE_APP_{ctx['securityContext']['tenant_id']}"

@config('context_to_orchestrator_id')
def context_to_orchestrator_id(ctx: dict) -> str:
  return f"CUBE_APP_{ctx['securityContext']['tenant_id']}"

module.exports = {
  contextToAppId: ({ securityContext }) => {
    return `CUBE_APP_${securityContext.tenant_id}`
  },

  contextToOrchestratorId: ({ securityContext }) => {
    return `CUBE_APP_${securityContext.tenant_id}`
  }
}

from cube import config

@config('driver_factory')
def driver_factory(ctx: dict) -> None:
  context = ctx['securityContext']
  data_source = ctx['dataSource']
 
  return {
    'type': 'postgres',
    'host': 'demo-db-examples.cube.dev',
    'user': 'cube',
    'password': '12345',
    'database': data_source
  }

module.exports = {
  driverFactory: ({ securityContext, dataSource }) => {
    return {
      type: 'postgres',
      host: 'demo-db-examples.cube.dev',
      user: 'cube',
      password: '12345',
      database: dataSource
    }
  }
}

const VeryCustomDriver = require('cube-custom-driver')

module.exports = {
  driverFactory: ({ securityContext, dataSource }) => {
    return new VeryCustomDriver({
      /* options */
    })
  }
}

from cube import config

config.orchestrator_options = {
  'continueWaitTimeout': 10,
  'rollupOnlyMode': False,
  'queryCacheOptions': {
    'refreshKeyRenewalThreshold': 30,
    'backgroundRenew': True,
    'queueOptions': {
      'concurrency': 3,
      'executionTimeout': 1000,
      'orphanedTimeout': 1000,
      'heartBeatInterval': 1000
    }
  },
  'preAggregationsOptions': {
    'externalRefresh': False,
    'maxPartitions': 100,
    'queueOptions': {
      'concurrency': 3,
      'executionTimeout': 1000,
      'orphanedTimeout': 1000,
      'heartBeatInterval': 1000
    }
  }
}

module.exports = {
  orchestratorOptions: {
    continueWaitTimeout: 10,
    rollupOnlyMode: false,
    queryCacheOptions: {
      refreshKeyRenewalThreshold: 30,
      backgroundRenew: true,
      queueOptions: {
        concurrency: 3,
        executionTimeout: 1000,
        orphanedTimeout: 1000,
        heartBeatInterval: 1000
      }
    },
    preAggregationsOptions: {
      externalRefresh: false,
      maxPartitions: 100,
      queueOptions: {
        concurrency: 3,
        executionTimeout: 1000,
        orphanedTimeout: 1000,
        heartBeatInterval: 1000
      }
    }
  }
}

from cube import config

@config('pre_aggregations_schema')
def pre_aggregations_schema(ctx: dict) -> str:
  return f"pre_aggregations_{ctx['securityContext']['tenant_id']}"

module.exports = {
  preAggregationsSchema: ({ securityContext }) => {
    return `pre_aggregations_${securityContext.tenant_id}`
  }
}

from cube import config

config.scheduled_refresh_timer = 60

module.exports = {
  scheduledRefreshTimer: 60
}

from cube import config

# An array of time zones
config.scheduled_refresh_time_zones = [
  'America/Vancouver',
  'America/Toronto'
]

# Alternatively, a function returning an array of time zones
@config('scheduled_refresh_time_zones')
def scheduled_refresh_time_zones(ctx: dict) -> list[str]:
  time_zones = {
    'tenant_1': ['America/New_York'],
    'tenant_2': ['America/Chicago'],
    'tenant_3': ['America/Los_Angeles']
  }
  default_time_zones = ['UTC']
  tenant_id = ctx['securityContext']['tenant_id']
  return time_zones.get(tenant_id, default_time_zones)

module.exports = {
  // An array of time zones
  scheduledRefreshTimeZones: [
    'America/Vancouver',
    'America/Toronto'
  ],

  // Alternatively, a function returning an array of time zones
  scheduledRefreshTimeZones: ({ securityContext }) => {
    let time_zones = {
      'tenant_1': ['America/New_York'],
      'tenant_2': ['America/Chicago'],
      'tenant_3': ['America/Los_Angeles']
    }
    let default_time_zones = ['UTC']  
    let tenant_id = securityContext.tenant_id
    return time_zones[tenant_id] || default_time_zones
  }
}

from cube import config

@config('scheduled_refresh_contexts')
def scheduled_refresh_contexts() -> list[object]:
  return [
    {
      'securityContext': {
        'tenant_id': 123,
        'bucket': 'demo'
      }
    },
    {
      'securityContext': {
        'tenant_id': 456,
        'bucket': 'demo_2'
      }
    }
  ]

module.exports = {
  scheduledRefreshContexts: () => [
    {
      securityContext: {
        tenant_id: 123,
        bucket: 'demo'
      }
    },
    {
      securityContext: {
        tenant_id: 456,
        bucket: 'demo_2'
      }
    }
  ]
}

from cube import config

@config('query_rewrite')
def query_rewrite(query: dict, ctx: dict) -> dict:
  context = ctx['securityContext']

  if 'filter_by_region' in context:
    query['filters'].append({
      'member': 'regions.id',
      'operator': 'equals',
      'values': [context['region_id']],
    })

  return query

module.exports = {
  queryRewrite: (query, { securityContext }) => {
    if (securityContext.filter_by_region) {
      query.filters.push({
        member: 'regions.id',
        operator: 'equals',
        values: [securityContext.region_id]
      })
    }
    return query
  }
}

from cube import config

@config('query_rewrite')
def query_rewrite(query: dict, ctx: dict) -> dict:
  raise Exception('You shall not pass! 🧙')

module.exports = {
  queryRewrite: (query, { securityContext }) => {
    throw new Error('You shall not pass! 🧙')
  }
}

from cube import config

config.allow_ungrouped_without_primary_key = True

module.exports = {
  allowUngroupedWithoutPrimaryKey: true
}

from cube import config

config.base_path = '/cube-api'

module.exports = {
  basePath: '/cube-api'
}

from cube import config

config.http = {
  'cors': {
    'origin': '*',
    'methods': 'GET,HEAD,PUT,PATCH,POST,DELETE',
    'preflightContinue': False,
    'optionsSuccessStatus': 204,
    'maxAge': 86400,
    'credentials': True
  }
}

module.exports = {
  http: {
    cors: {
      origin: '*',
      methods: 'GET,HEAD,PUT,PATCH,POST,DELETE',
      preflightContinue: false,
      optionsSuccessStatus: 204,
      maxAge: 86400,
      credentials: true
    }
  }
}

from cube import config

config.web_sockets_base_path = '/websocket'

module.exports = {
  webSocketsBasePath: '/websocket'
}

from cube import config

config.process_subscriptions_interval = 1000

module.exports = {
  processSubscriptionsInterval: true
}

from cube import config

@config('context_to_api_scopes')
def context_to_api_scopes(context: dict, default_scopes: list[str]) -> list[str]:
  return ['meta', 'data', 'graphql', 'sql']

module.exports = {
  contextToApiScopes: (securityContext, defaultScopes) => {
    return ['meta', 'data', 'graphql', 'sql']
  }
}

from cube import config
 
@config('extend_context')
def extend_context(req: dict) -> dict:
  req.setdefault('securityContext', {}).update({'active_organization': 123})
  # req.setdefault('securityContext', {}).update({'active_organization': req['headers']['active_organization']})
  return req
 
@config('context_to_app_id')
def context_to_app_id(ctx: dict) -> dict:
  return f"CUBE_APP_{ctx['securityContext']['active_organization']}"
 
 
 

module.exports = {
  extendContext: (req) => {
    return {
      securityContext: {
        ...req.securityContext,
        active_organization: 123
        // active_organization: req.headers.active_organization
      }
    }
  },

  contextToAppId: ({ securityContext }) => {
    return `CUBE_APP_${securityContext.active_organization}`
  }
}

{% set securityContext = COMPILE_CONTEXT['securityContext'] %}

cubes:
  - name: users
    sql: |
      SELECT *
      FROM users
      WHERE organization_id={{ securityContext['active_organization'] }}

const { securityContext } = COMPILE_CONTEXT

cube(`users`, {
  sql: `
    SELECT *
    FROM users
    WHERE organization_id=${securityContext.active_organization}
  `
})

from cube import config

@config('check_auth')
def check_auth(ctx: dict, token: str) -> None:
  if token == 'my_secret_token':
    return {
      'security_context': {
        'user_id': 42
      }
    }

  raise Exception('Access denied')

module.exports = {
  checkAuth: (ctx, token) => {
    if (token === 'my_secret_token') {
      return {
        security_context: {
          user_id: 42
        }
      }
    }

    throw new Error('Access denied')
  }
}

  jwt: {
    jwkUrl?: ((payload: any) => string) | string;
    key?: string;
    algorithms?: string[];
    issuer?: string[];
    audience?: string;
    subject?: string;
    claimsNamespace?: string;
  };

from cube import config

@config('check_sql_auth')
def check_sql_auth(req: dict, user_name: str, password: str) -> dict:
  if user_name == 'my_user':
    if password and password != 'my_password':
      raise Exception('Access denied')
    return {
      'password': password,
      'securityContext': {
        'some': 'data'
      }
    }

  raise Exception('Access denied')

module.exports = {
  checkSqlAuth: (req, user_name, password) => {
    if (user_name === 'my_user') {
      if (password && password !== 'my_password') {
        throw new Error('Access denied')
      }
      return {
        password,
        securityContext: {
          some: 'data'
        }
      }
    }

    throw new Error('Access denied')
  }
}

from cube import config
import os

@config('check_sql_auth')
def check_sql_auth(req: dict, user_name: str, password: str) -> dict:
  # Handle NTLM authentication:
  # - for Power BI `runas` command
  # - for Power BI gateway
  if req['protocol'] == 'xmla' and req['method'] == 'ntlm':
    if (user_name == os.environ.get('CUBEJS_SQL_USER')):
      return {
        'password': os.environ.get('CUBEJS_SQL_PASSWORD'),
        'securityContext': {}
      }
    
    return {
      'password': os.environ.get('CUBEJS_SQL_PASSWORD'),
      'securityContext': {}
    }

  raise Exception('Access denied')

module.exports = {
  checkSqlAuth: (req, user_name, password) => {
    // handle ntlm auth scenarios (PBI "runas" command + PBI gateway auth)
    if (req.protocol === 'xmla' && req.method === 'ntlm') {
      if (user_name === process.env.CUBEJS_SQL_USER) {
        return {
          password: process.env.CUBEJS_SQL_PASSWORD,
          securityContext: {}
        }
      }
      
      return {
        password: process.env.CUBEJS_SQL_PASSWORD,
        securityContext: {}
      }
    }

    throw new Error('Access denied')
  }
}

from cube import config

@config('can_switch_sql_user')
def can_switch_sql_user(current_user: str, new_user: str) -> dict:
  if current_user == 'admin':
    return True

  if current_user == 'service':
    return new_user != 'admin'

  return False

module.exports = {
  canSwitchSqlUser: (current_user, new_user) => {
    if (current_user === "admin") {
      return true
    }

    if (current_user === "service") {
      return new_user !== "admin"
    }

    return false
  }
}

from cube import config

@config('context_to_groups')
def context_to_groups(ctx: dict) -> list[str]:
  return ctx['securityContext'].get('groups', ['default'])

module.exports = {
  contextToGroups: ({ securityContext }) => {
    return securityContext.groups || ['default']
  }
}

from cube import config

@config('logger')
def logger(message: str, params: dict) -> None:
  print(f"{message}: {params}")

module.exports = {
  logger: (message, params) => {
    console.log(`${message}: ${JSON.stringify(params)}`)
  }
}

from cube import config

config.telemetry = True

module.exports = {
  telemetry: false
}

module.exports = {
  // string
  dbType: 'snowflake',

  // function
  dbType: ({ securityContext }) => 'databricks'
}

from cube import config

@config('context_to_roles')
def context_to_roles(ctx: dict) -> list[str]:
  return ctx['securityContext'].get('roles', ['default'])

module.exports = {
  contextToRoles: ({ securityContext }) => {
    return securityContext.roles || ['default']
  }
}