@omnifyjp/ts 3.23.0 → 3.23.2

package/dist/php/index.js

@@ -68,10 +68,12 @@ export function generatePhp(data, overrides) {
         // we add the standalone Common / Info / Schemas files.
         files.push(...generateOpenApi(reader, config));
     }
-    // Service layer (schemas with options.api OR options.service). Issue #57.
-    if (reader.hasApiSchemas() || reader.hasServiceSchemas()) {
-        files.push(...generateServices(reader, config));
-    }
+    // Service layer. #81 (v3.23.0): service generation is now opt-out by
+    // default — every project `kind: object` schema gets a base service
+    // unless explicitly opted out via `options.service: false`. The old
+    // opt-in gate here is gone because `generateServices` does its own
+    // filter internally; always call it and let it decide.
+    files.push(...generateServices(reader, config));
     // Issue #34: every `kind: enum` schema becomes a global PHP enum class.
     files.push(...generateEnums(reader, config));
     // Astrotomic translatable config (only when at least one schema has

package/dist/php/service-generator.js

@@ -32,27 +32,58 @@ import { baseFile, userFile, resolveModularBasePath, resolveModularBaseNamespace
 export function generateServices(reader, config) {
     const files = [];
     const candidates = {};
-    // Project-owned object schemas — the new default-enabled set (#81).
-    for (const [name, schema] of Object.entries(reader.getProjectObjectSchemas())) {
+    // #81 + #80 interaction (v3.23.1): iterate every project-owned schema
+    // directly instead of going through `getProjectObjectSchemas()`, which
+    // filters out KindPartial. Phantom-upstream extends (#80 self-reference
+    // fallback — e.g. `kind: extend, target: Product` with no upstream
+    // package loaded) are kept as KindPartial so downstream generators
+    // skip emitting tables for them, but their SERVICES still belong in
+    // the consumer project and must be generated here. Kind=object stays
+    // the opt-out default; Kind=partial/extend is included when the user
+    // has signalled service intent (legacy options.service block or any
+    // property-level service flag).
+    const allSchemas = reader.getSchemas();
+    for (const [name, schema] of Object.entries(allSchemas)) {
+        // Project-owned only — packages emit their own services in the
+        // owning package's codegen pass.
+        if (schema.package != null)
+            continue;
+        const kind = schema.kind ?? 'object';
+        // Hard exclusions: non-object-ish kinds never get services
+        if (kind === 'enum' || kind === 'pivot')
+            continue;
         // #81 explicit opt-out: `service: false` on the schema
         if (schema.options?.service === false) {
             continue;
         }
-        // Skip Astrotomic translation sidecars — they're auto-emitted as PHP
-        // translation models, not as full services. Heuristic by name suffix.
+        // Astrotomic translation sidecars — auto-emitted as PHP translation
+        // models, not full services. Heuristic by name suffix.
         if (name.endsWith('Translation')) {
             continue;
         }
-        // Skip hidden schemas (options.hidden = true) — intentional internal types
+        // Hidden schemas (options.hidden = true) — intentional internal types
         if (schema.options?.hidden) {
             continue;
         }
-        candidates[name] = schema;
+        if (kind === 'object') {
+            // Phase 2 default: every object schema gets a service
+            candidates[name] = schema;
+        }
+        else if (kind === 'partial' || kind === 'extend') {
+            // Phantom-upstream extend (#80 fallback). Only emit a service if the
+            // user signalled intent — either a legacy options.service block, or
+            // at least one property-level service flag (searchable / filterable /
+            // sortable / lookupable / defaultSort). An empty extend with no
+            // service config is not a service candidate — it's a stub the user
+            // added for property merging elsewhere.
+            if (schemaHasServiceIntent(schema)) {
+                candidates[name] = schema;
+            }
+        }
     }
     // Legacy `options.api` schemas — these are already in project set above
-    // (getSchemasWithApi is a subset of project schemas). We don't need a
-    // second pass for them unless someone sets `service: false` + `api: {}`
-    // on the same schema, in which case the explicit api opt-in wins.
+    // for most cases, but belt-and-suspenders: include any that slipped
+    // through the kind filter.
     for (const [name, schema] of Object.entries(reader.getSchemasWithApi())) {
         if (!candidates[name]) {
             candidates[name] = schema;
@@ -68,6 +99,34 @@ export function generateServices(reader, config) {
     }
     return files;
 }
+/**
+ * #81 + #80 (v3.23.1): detect "user wants a service for this schema" signal
+ * on extend/partial schemas. Returns true when either:
+ *   - the legacy options.service block is present (truthy, not false), OR
+ *   - at least one property has a service-related flag set.
+ *
+ * Phantom-upstream extends (#80 self-reference fallback) stay as KindPartial
+ * for migration purposes, but the consumer project still wants a service
+ * layer for calling into the externally-owned table. This helper tells the
+ * candidate selector to include those.
+ */
+function schemaHasServiceIntent(schema) {
+    const svc = schema.options?.service;
+    if (svc && typeof svc === 'object')
+        return true;
+    const properties = schema.properties ?? {};
+    for (const prop of Object.values(properties)) {
+        if (!prop)
+            continue;
+        if (prop.searchable || prop.filterable || prop.sortable)
+            return true;
+        if (prop.lookupable)
+            return true;
+        if (prop.defaultSort)
+            return true;
+    }
+    return false;
+}
 /**
  * Print a deprecation warning (once per schema) for every legacy
  * `options.service.*` key that duplicates property-level metadata.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@omnifyjp/ts",
-  "version": "3.23.0",
+  "version": "3.23.2",
   "description": "TypeScript model type generator from Omnify schemas.json",
   "type": "module",
   "main": "dist/index.js",