Definitions

• 1: Fields
• 2: Records
• 3: SQL Objects
• 4: File Layouts
• 5: Pages
• 6: Components
• 7: Component Interfaces
• 8: Menus
• 9: Content References
• 10: Message Catalogs
• 11: Application Packages
• 12: URL Definitions
• 13: HTML Definitions
• 14: Style Sheets
• 15: Change Control & Object Locks

1 - Fields

Fields (PSDBFIELD) are the fundamental, individual data elements in PeopleSoft—like an employee ID, first name, date of birth, or monetary amount. Think of a field as an individual column in a spreadsheet or a single entry box on a form. Every database table column and page control across PeopleSoft is built on top of a field definition. psLens reads field definitions from PSDBFIELD (and field labels from PSDBFLDLABL) and stitches them together with the rest of the metadata so you can see, in one place, everywhere a given field is used.

Object Relationships

Fields form the lowest-level data layer in the PeopleSoft object hierarchy:

• Included in Records: Fields (PSDBFIELD) are grouped into record definitions (PSRECFIELD) to form physical database tables, SQL views, and derived work buffers.
• Bound to Page Controls: Fields are bound to user interface controls (PSPNLFIELD) on pages to view or edit data.
• Exposed in Component Interfaces: Fields map to Component Interface properties (PSBCITEM) for programmatic API integrations.
• Referenced in Queries & PeopleCode: Fields are selected in PeopleSoft Queries (PSQRYFIELD) and referenced in PeopleCode logic across the application.

How psLens Improves Field Inspection

In Application Designer, assembling a complete picture of a field’s usage requires opening the field definition for properties and labels, right-clicking to run Find Object References for record usage, executing a separate Find In search across PeopleCode, manually running SQL against PSPNLFIELD and PSBCITEM to find page and CI usage, running Query Manager searches across databases, and inspecting containing App Designer projects one at a time for migration history.

psLens surfaces field properties, label definitions, containing records, page bindings, Component Interface properties, PeopleCode call sites, and query references on a single screen with one-click drilldowns.

Search Page

URL: /fields?db={database}

Type a partial field name to find matching definitions. Search auto-matches as starts with — EMPLID finds EMPLID, EMPLID_TBL, EMPLID_PNL, etc. Include % yourself for more control: %NAME (ends with), %DESCR% (contains), or just % to list every row. Each result card shows the field type and length, the long-name description, and the last-updated timestamp so you can spot recently modified objects at a glance. The Advanced Filters panel lets you narrow by field type, last-updated date, or owner. Recently viewed fields are surfaced just above the results.

Detail Page

URL: /fields/{FIELDNAME}?db={database}

The main pane shows the Field Properties card (type, length, format, description, object owner, last-updated metadata) and a Field Labels card with every long/short name pair defined in PSDBFLDLABL, including which one is the default label. The Export button in the top right downloads the full definition as Markdown. The Related Data sidebar holds six toggles that fetch additional context on demand.

Related Data Panels

Toggle any panel on to load it inline beneath the main content. Each panel returns the count of objects found and a sortable list with deep-links into the corresponding psLens detail pages, so you can chase a field reference into the record, page, or PeopleCode program that uses it without losing your place.

Records

Lists every record where the field appears, with record type, the position number within the record, key-field indicator, and whether the field is configured with an Edit Table prompt. Sourced from PSRECFIELD / PSRECFIELDDB.

Included in Projects

Shows every App Designer project (PSPROJECTITEM) that contains this field as a project item. Useful for tracing which customization or release introduced or modified the field.

PeopleCode References

Lists PeopleCode programs that mention the field: record PeopleCode, component PeopleCode, application package methods, and more. Each result links to the parent object’s detail page so you can drill into the program.

Pages

Lists pages (PSPNLFIELD) where a control on the page is bound to this field, with the record context. Useful for impact analysis when changing a field’s type or length.

Component Interfaces

Lists Component Interfaces that expose this field as a CI property. The integration surface area for the field. Sourced from PSBCITEM.

Queries

Lists PeopleSoft Queries (PSQRYFIELD) that reference this field in a SELECT, WHERE, or ORDER BY. Useful for security and audit work: “who has reports built on this column?”

2 - Records

Records are PeopleSoft’s table/view definitions — every database table, SQL view, derived/work record, and dynamic view is registered in PSRECDEFN. psLens reads the record definition plus its field list from PSRECFIELD and stitches it together with everywhere the record is referenced in pages, components, PeopleCode, queries, projects, and trees. The Records page has 12 related-data panels covering pages, components, PeopleCode, queries, trees, prompt-table back-references, AE statements, COBOL SQL statements, project membership, and a live row sample.

Object Relationships

Records connect underlying field definitions to user interfaces and security structures:

• Contains Fields: Records group individual field definitions (PSDBFIELD) into ordered record fields (PSRECFIELD).
• Bound to Pages: Fields on a record are bound to controls (PSPNLFIELD) on page definitions (PSPNLDEFN).
• Primary Search for Components: Records act as primary search records (SEARCHRECNAME) driving component key selection dialogs.
• Defined by SQL Objects: View-type records (RECTYPE = 1) derive their SELECT SQL definitions from SQL Objects (PSSQLDEFN).

How psLens Improves Record Inspection

A complete impact assessment for a record change in Application Designer requires opening the record definition for properties, fields, and events, running Find Object References to find pages using it, walking found pages to identify parent components, executing Find In searches across PeopleCode, manually querying PSAESTMTDEFN, PSQRYRECORD, and PSTREENODE for AE, query, and tree usage, checking prompt-table back-references, and opening SQL clients to sample rows.

psLens consolidates record schema fields, page bindings, component trees, PeopleCode events, query usage, prompt-table relationships, AE/COBOL SQL statements, project membership, and a live row sample into one page.

Search Page

URL: /records?db={database}

Search auto-matches as starts with — typing JOB finds JOB, JOB_DATA, JOBCODE, etc. For more control, include % yourself: %DATA (ends with), %PERS% (contains), or just % to list every row. Each card shows record type, field count, the descriptive long name, and last-updated metadata. The Advanced Filters panel lets you filter by record type (Table, View, Derived/Work, Subrecord, Dynamic View, Query View, Temp Table), object owner, and last-updated date.

Detail Page

URL: /records/{RECNAME}?db={database}

The main pane shows Record Properties (type, owner, audit options, system table flag, description, audit timestamps) and a full Record Fields table with each field’s type, length, key indicators, default value, and Edit Table prompt — every detail you’d otherwise open App Designer to confirm. The Export button downloads the full record definition as Markdown. The Related Data sidebar holds 12 toggles — the broadest set of any object type — covering every place this record is referenced.

Related Data Panels

Pages Using This Record

Lists pages with controls bound to this record (PSPNLFIELD join on RECNAME). Useful for impact analysis when changing the record schema.

Components Using This Record

Lists every component containing a page bound to this record — gives you the user-facing transactions affected by the record.

PeopleCode Events

Lists record-level PeopleCode events (FieldChange, RowInit, SaveEdit, etc.) attached to fields of this record. Sourced from PSPCMPROG.

Included in Projects

Lists App Designer projects (PSPROJECTITEM) that include this record — useful for migration history and change tracking.

Used in App Engines

Lists Application Engine programs whose SQL or PeopleCode steps reference this record. Sourced from PSAESTMTDEFN text scans.

Component Interfaces Using This Record

Lists Component Interfaces whose underlying component contains a page bound to this record — the integration surface area.

Record Data

Pulls a live sample of rows from the record using the psoftQL API — first ~10 rows with every column. Lets you see what the data actually looks like without opening App Designer’s Run-In-Query or a separate SQL client.

PeopleCode References

Broader than “Events” — finds any PeopleCode anywhere in the database that mentions this record by name (component, page, app package, app engine, message, signon, FieldFormula, etc.).

Queries Using This Record

Lists PeopleSoft Queries (PSQRYRECORD) that include this record in a FROM clause. Critical for audit work — “who is reporting from this table?”

Query Trees Using This Record

Lists Query Tree nodes (PSTREENODE) where this record appears — determines which query authors can build queries against it.

Used as Prompt Table

Lists fields on other records that point to this record as their Edit Table / Prompt Table — shows the lookup relationships that hang off this record.

COBOL SQL Statements

Lists stored COBOL SQL statements (SQLSTMT_TBL) that reference this record in their statement text, program name, or statement name. Displays the COBOL program (PGM_NAME), statement type (STMT_TYPE), statement name (STMT_NAME), and formatted SQL text.

3 - SQL Objects

SQL Objects are the PeopleSoft application’s standalone SQL artifacts — view definitions and other named SQL fragments stored in PSSQLDEFN / PSSQLTEXTDEFN. Unlike a record’s automatically-generated DDL, these are SQL bodies the developer hand-wrote and PeopleSoft keeps versioned with the rest of the metadata. psLens pulls the source SQL plus the related record (when the SQL object is a view tied to a record definition) so you don’t switch into App Designer to read the SQL.

Object Relationships

SQL Objects define custom SQL statements for database views and code modules:

• Defines Record Views: SQL Objects (PSSQLDEFN) contain the underlying SELECT statements that define SQL view records (RECTYPE = 1).
• Called by PeopleCode & App Engines: Standalone SQL objects are executed in code via FetchSQL() or Application Engine SQL actions.

How psLens Improves SQL Object Inspection

Reading SQL Objects in Application Designer requires searching SQL definitions, opening the object editor, right-clicking to find backing records, and checking projects individually for migration history.

psLens presents syntax-highlighted SQL source code inline, with direct links to backing record definitions and project membership.

Search Page

URL: /sqlobjects?db={database}

Search auto-matches as starts with. Typing PT finds every SQL object whose ID begins with PT. Include % yourself for ends-with (%VW) or contains (%AUDIT%) patterns, or use % alone to list every row. Each result shows the object name, type, and last-updated info, useful when you’re tracing where a view body is defined or hunting for a delivered SQL fragment.

Detail Page

URL: /sqlobjects/{NAME}?db={database}

The main pane shows the object’s properties and the full Source SQL body, syntax-highlighted and copyable, so you can see what the view SELECTs without an App Designer round-trip. The sidebar has two related-data toggles.

Related Data Panels

Source Record

When the SQL object is the body of a view-type record, this panel links into the parent record’s detail page so you can see the field list and the rest of the record metadata in one click.

Included in Projects

Lists projects that contain this SQL object as a project item. Useful for tracing migration history of view DDL changes.

4 - File Layouts

File Layout definitions (PSFLDDEFN) map structured flat files, CSVs, fixed-position files, and XML documents to PeopleSoft rowsets and record structures. PeopleTools Object Type 31 definitions store file format specifications in PSFLDDEFN, segment hierarchies in PSFLDSEGDEFN, and field attributes in PSFLDFIELDDEFN. Batch processes and PeopleCode programs query these definitions at runtime to parse inbound files or render outbound data extracts.

psLens pulls the file layout properties, segment hierarchy tree, mapped records, field positional attributes, owning App Designer projects, and referencing PeopleCode programs into a single browser view.

Object Relationships

File Layouts translate external files into PeopleSoft record structures:

• Maps File Segments to Records: File Layouts (PSFLDDEFN) contain segment hierarchies (PSFLDSEGDEFN) that map file lines to underlying target records (RECNAME_FILE).
• Maps File Fields to Record Fields: File fields (PSFLDFIELDDEFN) map positional or delimited file data to specific record fields.
• Invoked in PeopleCode & App Engines: Batch programs instantiate File Layouts (GetFileLayout) to parse or generate flat files.

How psLens Improves File Layout Inspection

In Application Designer, inspecting File Layouts requires expanding segment nodes in the tree control, clicking into individual field properties, and running Find In PeopleCode searches for referencing scripts.

psLens presents layout format properties, segment hierarchies, field positional attributes, project membership, and referencing PeopleCode programs in a single view.

Search Page

URL: /filelayouts?db={database}

• Search: Search by File Layout name or description (prefix match). Wildcard % search is supported (for example, %BANK% to find banking layout definitions or % to list all rows).
• Filters: Filter search results by last updated operator (LastUpdOprid), last updated date range (DateFrom / DateTo), or customized definitions (CustomizedOnly).
• Metadata Cards: Each result card displays the file layout name, description, file format type (CSV, Fixed, or XML), segment count, and last updated operator and timestamp.

Detail Page

URL: /filelayouts/{FLNAME}?db={database}

The Detail Page consolidates the definition attributes, segment hierarchy, field specifications, and cross-object references:

• File Layout Properties: Displays description, file format type (CSV, Fixed Position, XML), record delimiter, field qualifier, space stripping behavior, Excel formatting flags, segment count, and modification audit metadata (LASTUPDDTTM, LASTUPDOPRID).
• Segment & Field Hierarchy: Renders a tree of segments (PSFLDSEGDEFN) and fields (PSFLDFIELDDEFN). For each segment, psLens displays its parent segment, segment ID prefix, mapped record (RECNAME_FILE), and field count. For each field, psLens lists the field name, start position, length, decimal precision, date format mask, and date separator.
• Export as Markdown: Generates a structured Markdown export (/filelayouts/{FLNAME}/export) containing an ASCII segment hierarchy tree, complete field lists, project membership, and referencing PeopleCode programs.

Related Data Panels

Included in Projects

Queries PSPROJECTITEM where OBJECTTYPE = 31 to display Application Designer projects containing this File Layout definition.

PeopleCode References

Queries PSPCMNAME to list all PeopleCode programs (Application Engine steps, Component PeopleCode, Record PeopleCode, or Application Package methods) that reference the File Layout name in code statements.

5 - Pages

Pages are the visual screens users interact with in PeopleSoft: the panel definitions from PSPNLDEFN and the per-control bindings from PSPNLFIELD. psLens shows the full control list (every field, label, group box, and subpage on the page), the underlying records each control reads from, and the rest of the metadata graph hanging off the page: which components include it, which PeopleCode is attached, which projects contain it.

Object Relationships

Pages bridge individual record fields to complete application transactions:

• Binds Record Fields: Pages (PSPNLDEFN) contain visual controls (PSPNLFIELD) bound to fields (FIELDNAME) on underlying records (RECNAME).
• Grouped in Components: One or more pages are assembled into a component definition (PSPNLGROUP) to create a complete transaction.
• Includes Subpages: Pages embed reusable subpages and secondary pages to modularize user interface design.

How psLens Improves Page Inspection

Investigating page definitions in Application Designer requires opening the page layout, double-clicking individual controls to verify record and field bindings, querying PSPNLGROUP to find parent components, checking page properties for Activate PeopleCode, and walking owning projects for migration history.

psLens presents the full control inventory, distinct underlying records, embedded subpages, containing components, Activate PeopleCode, and project membership in a single view with everything one click away.

Search Page

URL: /pages?db={database}

Wildcard % search supported. Each result card shows the page type (Standard Page, Subpage, Secondary Page, or Search Record) so you can spot reusable subpages versus standalone screens at a glance. The Advanced Filters panel lets you exclude subpages or limit to standard pages only.

Detail Page

URL: /pages/{PAGENAME}?db={database}

The main pane shows Page Properties (type, size, style, audit metadata) and the full Page Fields/Controls table with each control’s record/field binding, label, occurs level, and field type. The sidebar has 6 related-data toggles.

Related Data Panels

Page Fields/Controls

The control inventory: every field control on the page with its PSPNLFIELD row attributes. Each record/field reference deep-links into the matching psLens detail page.

Records Used on Page

The de-duplicated list of records this page reads from. Clicking a record opens its detail page so you can confirm the schema, sample data, or check what else uses it.

Subpages Included

Lists every subpage embedded inside this page. Useful when a control’s data seems to come from somewhere “magic” (it’s almost always a subpage doing the work).

Components Using Page

Lists the components that include this page. Answers “which transactions show this screen to a user?”

PeopleCode

Page Activate PeopleCode. The only event type that lives directly on a page object.

Included in Projects

App Designer projects containing this page as a project item.

6 - Components

Components (called panel groups in older PeopleTools versions) are the user-facing transactions of a PeopleSoft application: a search page plus an ordered set of detail pages that share a single save action. psLens reads PSPNLGROUP / PSPNLGRPDEFN and links the component up to its menus, portal navigation paths, exposing component interfaces, the underlying record hierarchy, and the full PeopleCode event tree.

Object Relationships

Components unite visual pages, database records, security grants, and navigation:

• Groups Pages: Components (PSPNLGRPDEFN) assemble ordered lists of pages (PSPNLGROUP) into a unified transaction with shared state.
• Driven by Search Records: Components rely on a primary search record (SEARCHRECNAME) to execute key lookups and search dialogs.
• Linked to Menus: Components are assigned to menu items (PSMENUITEM) inside classic menus (PSMENUDEFN).
• Targeted by CREFs & CIs: Portal Content References (PSPRSMDEFN) expose components to users, and Component Interfaces (PSBCDEFN) expose them to API code.

How psLens Improves Component Inspection

Tracing component metadata in Application Designer and PIA requires opening the component item list, walking page tabs to confirm record bindings, running Find In Menus for classic navigation links, navigating the Portal Registry browser for CREF breadcrumbs, searching for exposing Component Interfaces, and opening event PeopleCode across multiple tabs.

psLens combines component properties, page lists, classic menu links, portal registry paths, exposing Component Interfaces, scroll record hierarchies, component event PeopleCode, and project membership onto a single screen.

Search Page

URL: /components?db={database}

Wildcard % search supported. Each result card shows the component market and use type (Classic, Fluid, Both). The Advanced Filters panel filters by market or component type.

Detail Page

URL: /components/{COMPONENT}?db={database}

The main pane shows Component Properties (market, search record, add search record, item description, add/update modes, search PeopleCode flags) and the Component Item List with every page in the component, its labeling, and the hide/display-only flags. The sidebar has 7 related-data toggles.

Related Data Panels

Pages in Component

The page list with each page deep-linked into its own detail page.

Menus Using Component

Every classic menu (PSMENUITEM) that contains a navigation entry for this component. Important for security work since menu/component pairs drive Permission List authorizations.

Portal Navigation Paths

The full set of portal registry paths (PSPRSMDEFN ancestor walk) that lead a user to this component. Useful for “where is this transaction in the menu?” questions.

Component Interfaces

The CIs (PSBCDEFN) that wrap this component as an integration surface. If you have CIs here, programmatic access exists.

Record Level Hierarchy

The scroll/record hierarchy across the pages. Shows the parent-child relationships of records as the component sees them at runtime.

PeopleCode

Component-level PeopleCode events (SearchInit, SearchSave, PreBuild, PostBuild, SavePreChange, SavePostChange, Workflow, etc.) and Component Record/Component Record Field PeopleCode.

Included in Projects

App Designer projects containing this component as a project item.

7 - Component Interfaces

Component Interfaces (CIs) are PeopleSoft’s programmatic façade over a component. They expose component properties as get/set properties and component events as callable methods, so integration code can drive the same business logic the UI uses. psLens reads PSBCDEFN for the CI header, PSBCITEM for the property/key list, and PSBCMETHODS for the methods. It also runs two consistency checks against the underlying component to catch the most common breakage: properties that no longer map to a valid record field, and required fields the CI doesn’t expose.

Object Relationships

Component Interfaces expose interactive transaction components for programmatic API access:

• Wraps Components: Component Interfaces (PSBCDEFN) target an underlying component (PNLGRPNAME, MARKET) to expose its validation logic.
• Maps Properties to Record Fields: CI items (PSBCITEM) bind exposed API properties to specific record fields (PSRECFIELD) on the component.
• Secured by Permission Lists: Permission lists (PSAUTHBUSCOMP) grant action-level permissions (Get, Create, Save) on Component Interfaces.

How psLens Improves Component Interface Inspection

Evaluating Component Interfaces in Application Designer requires opening the CI item tree, cross-referencing record fields on the underlying component, manually scanning for missing required fields, and running Find In PeopleCode for calling programs.

psLens automates consistency checks—flagging invalid property bindings and missing required component fields—while displaying methods, properties, referencing PeopleCode, and project membership in one place.

Search Page

URL: /componentinterfaces?db={database}

Wildcard % search supported. Each result card shows the underlying component and CI description.

Detail Page

URL: /componentinterfaces/{CINAME}?db={database}

The main pane shows Component Interface Properties (underlying component, market, security access, owner) plus the items list. The sidebar has 6 related-data toggles, including two consistency-check panels unique to CIs.

Related Data Panels

Items

Every CI property (PSBCITEM): its record/field binding, key indicator, and whether it’s a standard or custom-named property.

CI Methods

Standard methods (Get, Find, Create, Save, Cancel) plus any user-defined methods. Each method links into the matching PeopleCode.

Invalid Properties Check

A consistency check. Flags CI items that no longer match a valid record field on the underlying component — the most common failure mode after a record schema change.

Missing Fields

A consistency check. Flags fields on the underlying component that are required (key fields, search keys, required-input fields) but are not exposed as CI properties. Helps spot where a CI cannot drive a transaction to completion.

PeopleCode References

PeopleCode programs anywhere in the database that mention this CI by name. Useful for finding the App Engine, Service Operation handler, or other CI program that drives this interface.

Included in Projects

App Designer projects that include this CI.

8 - Menus

Menus are PeopleSoft’s classic navigation containers. Each menu (PSMENUDEFN) holds a set of bars, each bar a set of items (PSMENUITEM), and each item points to a component the user can launch. Even in a Fluid-dominant world, classic menus matter for security: Permission List authorizations are granted on menu/component pairs, so understanding which menu owns a component is fundamental to access analysis.

Object Relationships

Menus organize business transactions into structured navigation and security access paths:

• Points to Components: Menu items (PSMENUITEM) inside a menu (PSMENUDEFN) specify the target component (PNLGRPNAME) and market (MARKET).
• Secured by Permission Lists: Permission lists (PSAUTHITEM) authorize user access to specific menu item and component combinations.
• Referenced by Portal CREFs: Portal content references (PSPRSMDEFN) use menu and component URI segments to populate navigation trees.

How psLens Improves Menu Inspection

In Application Designer, inspecting classic menus requires opening the menu tree, double-clicking individual items to confirm target component and market properties, and right-clicking items to navigate to component definitions.

psLens displays the complete bar and item hierarchy on a single screen with direct links to target components, making it straightforward to audit security pairs and navigation structures.

Search Page

URL: /menus?db={database}

Wildcard % search supported. Each card shows the menu type (Standard or Pop-up) and the descriptive long name.

Detail Page

URL: /menus/{MENUNAME}?db={database}

The main pane shows Menu Properties (type, owner, audit metadata). The sidebar has 2 related-data toggles.

Related Data Panels

Menu Items

Every bar and item in the menu, with the component (and market) each item launches. Each component is deep-linked into its own psLens detail page, letting you walk straight from a menu entry into the transaction it triggers.

Included in Projects

App Designer projects that include this menu.

9 - Content References

Content References (CREFs) are entries in the PeopleSoft Portal Registry — the data structure that drives the menu tree, breadcrumbs, and navigation collections users see in PIA. Each CREF is identified by a portal/object name pair stored in PSPRSMDEFN and can be either a folder (a navigation container) or a content reference (a launchable target, usually a component, but also iScripts, external URLs, and homepage pagelets). psLens shows the CREF’s URI target, the full ancestor walk back to the portal root, every system and custom attribute, and the permission lists that have been granted access.

Object Relationships

Portal Content References link user navigation elements to target application objects:

• Targets Components & External URLs: CREFs (PSPRSMDEFN) map portal links to components (PSPNLGRPDEFN), iScripts, or external web addresses.
• Organized in Portal Folders: CREFs are arranged hierarchically inside parent folder nodes within the portal registry tree.
• Secured by Permission Lists & Roles: Permission lists and roles (PSPRSMPERM) grant user authorization to view CREFs and portal folders.

How psLens Improves Content Reference Inspection

In PIA, analyzing a Portal Content Reference requires navigating down multi-level folder trees in Structure & Content, switching between administration and permission tabs, and repeatedly editing parent folders to trace breadcrumbs.

psLens displays the complete portal entry—destination URI, full ancestor breadcrumb path, custom/system attributes, and permission list grants—on a single screen.

Search Page

URL: /crefs?db={database}

Search by CREF name or label, with optional filters for portal (EMPLOYEE, CUSTOMER, MOBILE, etc.) and type (CREF vs Folder). Each result card shows the portal, the parent folder path, and the target object name.

Detail Page

URL: /crefs/{PORTAL}/{OBJECTNAME}?db={database}

The main pane shows Properties (portal, parent folder, type, security author, label, description) and the URI / Target card with the destination URL. For component CREFs this is the menu/component path; for iScripts, the iScript URL; for external CREFs, the literal URL. The sidebar has 4 related-data toggles.

Related Data Panels

Navigation Path

The full ancestor chain from the portal root down to this CREF. Every folder in the navigation path is clickable so you can hop up the tree to a parent folder.

Custom Attributes

Per-CREF custom attribute name/value pairs from PSPRSMATTRVAL. Used by Fluid navigation collections, search categories, badges, and other portal features.

System Attributes

System attributes from PSPRSMSYSATTRVL with friendly labels (e.g., PORTAL_LABEL, PORTAL_OBJTYPE_DESC, PTPP_* personalization keys). These configure how the CREF behaves at runtime.

Permissions

Permission lists (PSPRSMPERM) that have been granted access to this CREF — the security side of “who can see this in the menu?”.

10 - Message Catalogs

The Message Catalog is PeopleSoft’s centralized store of user-facing text. Every MsgGet() call, error dialog, warning, and translated label resolves to a message set + message number pair stored in PSMSGCATDEFN. psLens lets you browse messages by set number, jump directly to a specific set/number, or search by message text. Each message gets a dedicated detail page with its severity, text, explanation, and a usage analysis that finds where it is referenced in PeopleCode and SQL.

Object Relationships

Message Catalogs standardize application message strings across components and scripts:

• Referenced in PeopleCode & SQL: Message Catalog entries (PSMSGCATDEFN) are called by MsgGet() and MsgGetText() in PeopleCode to display formatted messages.

How psLens Improves Message Catalog Inspection

In PIA, searching Message Catalog entries requires navigating Utilities → Administration → Message Catalog, while tracking down where a message is invoked requires running separate Find In PeopleCode searches.

psLens allows instant jumping to Set/Number pairs, surfaces recently modified messages, and automatically performs global usage analysis across all PeopleCode and SQL statements.

Search Page

URL: /messagecatalogs?db={database}

The search page has three entry points: enter a Set Number to see every message in the set, enter free text to Search Message Text, or punch in a specific Set/Number pair to jump straight to that message. The page also surfaces the highest set numbers in use (handy for picking the next free set when creating customizations) and the most recently modified messages.

Detail Page

URL: /messagecatalogs/{SET}/{NUMBER}?db={database}

The detail page has no sidebar toggles; everything loads inline. The main pane shows Message Properties (set, number, severity, last-updated), the full Message Text (with %1, %2 substitution markers preserved), and the Description / Explanation body text developers see when investigating a message.

Usage Analysis

The Usage Analysis card automatically scans every PeopleCode program and SQL object in the database for textual references to this set/number pair: MsgGet(18, 1, ...), MsgGetText(18, 1, ...), SQLExec("...18, 1..."), and so on. Each hit links to the parent object’s detail page. Lets you find every MsgGet / MsgGetText / SQLExec call site for the set/number pair before editing the text.

11 - Application Packages

Application Packages are PeopleSoft’s object-oriented PeopleCode container — packages hold sub-packages and classes, classes hold methods and properties. They are the standard way to write reusable PeopleCode in PeopleSoft applications. psLens walks the package tree (PSPACKAGEDEFN, PSPACKAGEITEM, PSPCMPROG) and shows the full class hierarchy plus a reverse index of where the package is used: by service operation handlers, by other PeopleCode, and in which projects.

Object Relationships

Application Packages organize reusable application logic across PeopleSoft objects:

• Contains Sub-packages & Classes: Packages (PSPACKAGEDEFN) structure object-oriented classes (PSPACKAGEITEM) into hierarchical namespaces.
• Executes via Handlers & PeopleCode: Classes define methods and properties called by Integration Broker operation handlers (PSOPRHDLR), App Engine steps, and event PeopleCode.

How psLens Improves Application Package Inspection

In Application Designer, inspecting application packages requires manually expanding sub-packages and class nodes, opening individual classes to view methods and properties, running Find In PeopleCode for import statements, and opening Integration Broker service operations one by one to find handler classes.

psLens exposes the fully expanded recursive package tree, caller call sites, IB service operation handlers, and project membership on a single screen.

Search Page

URL: /apppackages?db={database}

Wildcard % search supported. Each result card shows the package name and the top-level class names inside it.

Detail Page

URL: /apppackages/{PACKAGENAME}?db={database}

The main pane shows Package Properties (owner, last-updated, source path) and the full Package Structure, a recursive tree of sub-packages and classes with methods, properties, and visibility markers. The sidebar has 3 related-data toggles.

Related Data Panels

Package Structure

The recursive package tree showing every sub-package, class, method, and property. The equivalent of expanding every node in App Designer’s package browser at once. Methods link into their PeopleCode source.

Projects Containing This Package

App Designer projects that include this package as a project item.

Service Operations Using This Package

Integration Broker service operations whose handler is implemented in this package. Lists the IB endpoints that route through this code.

PeopleCode References

PeopleCode programs anywhere in the database that import or instantiate classes from this package — the impact view before refactoring.

12 - URL Definitions

URL definitions are PeopleSoft’s centralized store of named URL strings. Instead of hard-coding https://example.com/... inside PeopleCode, developers define a URL object (PSURLDEFN) and reference it by name with GetURL("MY_URL"). This keeps environment-specific endpoints (file servers, integration partners, image hosts) out of the code. psLens lets you browse the catalog so you can see every URL the application uses in one place.

Object Relationships

URL Definitions centralize external endpoint strings for application code:

• Referenced in PeopleCode: URL definitions (PSURLDEFN) are resolved dynamically in PeopleCode via GetURL() calls for attachments, redirects, and integrations.

How psLens Improves URL Definition Inspection

In Application Designer, searching URL definitions requires opening File → Open → URL Definition and clicking into individual items to inspect values.

psLens makes the URL catalog searchable with resolved URL endpoint values and owning project membership displayed inline.

Search Page

URL: /urls?db={database}

Wildcard % search supported. Each card shows the URL name plus the resolved URL value so you can scan the catalog at a glance.

Detail Page

URL: /urls/{URLNAME}?db={database}

The main pane shows URL Properties (the URL itself, description, comments, audit metadata). The sidebar has one related-data toggle.

Related Data Panels

Included in Projects

App Designer projects that include this URL. Useful for understanding which feature or customization introduced the URL.

13 - HTML Definitions

HTML definitions are PeopleSoft’s catalog of HTML fragments, JavaScript snippets, and template bodies stored in PSCONTDEFN. Anything a page or report needs to embed — a JavaScript helper, an email body template, a custom Fluid grid layout — is normally stored as a named HTML object and pulled into PeopleCode with GetHTMLText(). psLens shows the full content of the definition so you can read what the application is actually injecting at runtime.

Object Relationships

HTML Definitions provide reusable markup and script templates:

• Embedded in Pages: HTML definitions (PSCONTDEFN) store HTML/JS fragments bound to HTML area controls on page definitions.
• Loaded via PeopleCode: Programs invoke GetHTMLText() to retrieve and interpolate dynamic values into HTML templates.

How psLens Improves HTML Definition Inspection

In Application Designer, inspecting HTML definitions requires opening individual objects through File → Open → HTML and loading each item into separate editor windows.

psLens makes the entire HTML definition catalog instantly searchable with syntax-highlighted content and project membership presented inline.

Search Page

URL: /htmldefs?db={database}

Wildcard % search supported. Each card shows the HTML object’s name and last-updated metadata.

Detail Page

URL: /htmldefs/{NAME}?db={database}

The main pane shows HTML Definition Properties (description, audit metadata) and the full HTML Content body, syntax-highlighted. The sidebar has one related-data toggle.

Related Data Panels

Included in Projects

App Designer projects that include this HTML object.

14 - Style Sheets

Style sheet definitions are PeopleSoft’s stored CSS objects (PSSTYLEDEFN) — the cascading style sheets that drive Classic and Fluid UI rendering. Tools, themes, branding overrides, and per-page substyle sheets all live here. psLens shows the full CSS body so you can read what rules a specific style sheet contributes without extracting it through App Designer or scraping rendered HTML.

Object Relationships

Style Sheets format user interface rendering across pages and themes:

• Attached to Pages & Themes: Style Sheets (PSSTYLEDEFN) define CSS rules attached to page definitions, components, and portal branding themes.

How psLens Improves Style Sheet Inspection

In Application Designer, reviewing style sheets requires opening individual objects through File → Open → Style Sheet and examining CSS rules in separate tab windows.

psLens renders searchable, syntax-highlighted CSS source code directly in the browser alongside owning project membership.

Search Page

URL: /styledefs?db={database}

Wildcard % search supported. Each card shows the style sheet name and last-updated metadata.

Detail Page

URL: /styledefs/{NAME}?db={database}

The main pane shows Style Sheet Definition Properties (description, audit metadata) and the full CSS Content body, syntax-highlighted. The sidebar has one related-data toggle.

Related Data Panels

Included in Projects

App Designer projects that include this style sheet.

15 - Change Control & Object Locks

PeopleTools Change Control & Object Locks

In PeopleSoft development environments, PeopleTools Change Control prevents simultaneous modifications to application metadata objects by allowing developers to check out and lock definitions (e.g. Records, Pages, Components, PeopleCode, App Engines, Component Interfaces).

psLens automatically inspects system-wide Change Control configuration (PSCHGCTLDEF) and active checkout locks (PSCHGCTLLOCK) whenever you view definition metadata or related project associations.

How psLens Displays Object Lock Status

When inspecting any PeopleSoft definition in psLens (such as a Record, Page, Component, or Field), the Included in Projects panel surfaces Change Control state in real-time:

• Locked Objects: If a developer has checked out the object in Application Designer, psLens displays a prominent lock banner showing:
  • Operator ID (OPRID): The developer holding the active lock.
  • Lock Timestamp: When the object was checked out.
  • Associated Project: Direct link to the project (PSPROJECTDEFN) under which the definition is locked.
  • Developer Comments: Any check-out justification comments provided.
• Unlocked Objects: When Change Control is enabled in the database and no active lock exists, psLens displays a green status badge confirming the object is available for checkout.
• Change Control Disabled: If Change Control is disabled system-wide in the environment, psLens cleanly renders project associations without lock overhead.

Supported Object Types

Change Control and lock tracking is supported across all major PeopleSoft metadata definitions:

• Records & Tables (PSRECDEFN)
• Fields (PSDBFIELD)
• Pages (PSPNLDEFN)
• Components (PSPNLGRPDEFN)
• Menus (PSMENUDEFN)
• Application Engine Programs (PSAPPLDEFN)
• Component Interfaces (PSBCDEFN)
• Integration Nodes & Messages (PSMSGNODEDEFN, PSMSGDEFN)
• BI Publisher Reports & Templates (PSXPRPTDEFN)
• HTML Definitions, Style Sheets, and URLs